1. Ve studijních materiálech předmětu v ISu – soubory PDF ve složce text, zdrojový balík ve složkách 00 (organizační informace), 01 až 12 (jednotlivé kapitoly = týdny semestru), dále s1 až s3 (sady úloh) a konečně ve složce sol vzorová řešení. Doporučujeme soubory stahovat dávkově pomocí volby „stáhnout jako ZIP“.
2. Po přihlášení na studentský server aisa (buď za pomoci ssh nebo putty) zadáním příkazu pb111 update. Všechny výše uvedené složky pak naleznete ve složce ~/pb111.

• „#X“ – číslo týdne v semestru,
• „cv0“ – tento týden běží „nulté“ cvičení (kapitola B),
• „cv1“ – tento týden probíhají cvičení ke kapitole 1,
• „X/v“ – mezivýsledek verity testů příprav ke kapitole X,
• „X/p“ – poslední termín odevzdání příprav ke kapitole X,
• „sX/Y“ – Yté kolo verity testů k sadě X,
• „sX/z₁“ – první kolo známek za kvalitu kódu sady X,
• „sX/op“ – termín pro opravná odevzdání sady X,
• „sX/z₂“ – finální známky za kvalitu kódu sady X,
• „test“ – termín programovacího testu.

• za každou úspěšně odevzdanou přípravu 1 bod (max. 6 bodů každý týden, nebo 24/blok),
• za každou přípravu, která projde „verity“ testy navíc 0,5 bodu (max. 3 body každý týden, nebo 12/blok),
• za účast⁵ na cvičení získáte 3 body (max. tedy 12/blok),
• za aktivitu ve cvičení 3 body (max. tedy 12/blok).

• 10 bodů za úspěšně vyřešený příklad ze sady domácích úloh (celkem vždy 60/blok).

• za kvalitu kódu max. 5 bodů za příklad (celkem 30/blok).

• 15 bodů za každý zkouškový příklad (celkem 90/blok).

• blok 1: 60/120 bodů,
• blok 2: 60/150 bodů,
• blok 3: 60/150 bodů,
• blok 4: 60/120 bodů (neplatí pro ukončení zápočtem).

1. do odevzdávárny s názvem NN v ISu (např. 01),
2. příkazem pb111 submit ve složce ~/pb111/NN.

• „01/v“ – předběžné (čtvrteční) verity testy pro příklady z první kapitoly,
• „01/p“ – poslední (sobotní) termín odevzdání příprav z 1. kapitoly,
• analogicky pro další kapitoly.

1. analyzovat problémy, na které jste při samostatné domácí práci narazili, a zejména prodiskutovat, jak je vyřešit,
2. řešit programátorské problémy společně (s cvičícím, ve dvojici, ve skupině) – nahlédnout jak o programech a programování uvažují ostatní a užitečné prvky si osvojit.

• cvičící vybere ty z Vámi odevzdaných příprav, které se mu zdají něčím zajímavé – ať už v pozitivním, nebo negativním smyslu,
  • řešení bude anonymně promítat na plátno a u každého otevře diskusi o tom, čím je zajímavé;
  • Vaším úkolem je aktivně se do této diskuse zapojit (můžete se například ptát proč je daná věc dobře nebo špatně a jak by se udělala lépe, vyjádřit svůj názor, odpovídat na dotazy cvičícího),
  • k promítnutému řešení se můžete přihlásit a ostatním přiblížit, proč je napsané tak jak je, nebo klidně i rozporovat případnou kritiku (není to ale vůbec nutné),
• dále podobným způsobem vybere vzájemné (peer) recenze, které jste v předchozím týdnu psali, a stručně je s Vámi prodiskutuje (celkovou strukturu recenze, proč je který komentář dobrý nebo nikoliv, jestli nějaký komentář chybí, atp.) – opět se můžete (resp. byste se měli) zapojovat,
• na Vaši žádost lze ve cvičení analogicky probrat neúšpěšná řešení příkladů (a to jak příprav, tak příkladů z uzavřených sad).

1. Můžete se přihlásit k řešení příkladu na plátně, kdy primárně vymýšlíte řešení Vy, ale zbytek třídy Vám bude podle potřeby radit, nebo se ptát co/jak/proč se v řešení děje. U jednodušších příkladů se od Vás bude také očekávat, že jako součást řešení doplníte testy.
2. Cvičící Vám může zadat práci ve dvojicích – první dvojice, která se dopracuje k funkčnímu řešení získá možnost své řešení předvést zbytku třídy – vysvětlit jak a proč funguje, odpovědět na případné dotazy, opravit chyby, které v řešení publikum najde, atp. – a získat tak body za aktivitu. Získané 3 body budou rozděleny rovným dílem mezi vítězné řešitele.
3. příklad můžete také řešit společně jako skupina – takto vymyšlený kód bude zapisovat cvičící (body za aktivitu se v tomto případě neudělují).

1. do odevzdávárny s názvem sN_úkol v ISu (např. s1_a_queens),
2. příkazem pb111 submit sN_úkol ve složce ~/pb111/sN, např. pb111 submit s1_a_queens.

• „syntax“ – kontroluje, že odevzdaný program je syntakticky správně, lze jej přeložit a prochází základními statickými kontrolami,
• „sanity“ – kontroluje, že odevzdaný program se chová „rozumně“ na jednoduchých případech vstupu; tyto testy jsou rozsahem a stylem podobné těm, které máte přiložené k příkladům ve cvičení,
• „verity“ – důkladně kontrolují správnost řešení, včetně složitých vstupů a okrajových případů a kontroly paměťových chyb.

• kontrola „syntax“ se provede obratem (do cca 5 minut od odevzdání),
• kontrola „sanity“ každých 6 hodin počínaje půlnocí (tzn. 0:00, 6:00, 12:00, 18:00),
• kontrola „verity“ se provede v pondělí, středu a pátek ve 23:59 (dle tabulky uvedené výše).

• sada 1: 60 za funkčnost v bloku 1 + 30 za kvalitu v bloku 2,
• sada 2: 60 za funkčnost v bloku 2 + 30 za kvalitu v bloku 3,
• sada 3: 60 za funkčnost v bloku 3 + 30 za kvalitu v bloku 4 (zkouškovém).

• hodnocení A dostane takové řešení, které jasně popisuje řešení zadaného problému, je správně dekomponované na podproblémy, je zapsáno bez zbytečného opakování, a používá správné abstrakce, algoritmy a datové struktury,
• hodnocení B dostane program, který má výrazné nedostatky v jedné, nebo nezanedbatelné nedostatky ve dvou oblastech výše zmíněných, například:
  • je relativně dobře dekomponovaný a zbytečně se neopakuje, ale používá nevhodný algoritmus nebo datovou strukturu a není zapsán příliš přehledně,
  • používá optimální algoritmus a datové struktury a je dobře dekomponovaný, ale lokálně opakuje tentýž kód s drobnými obměnami, a občas používá zavádějící nebo jinak nevhodná jména podprogramů, proměnných atp.,
  • jinak dobrý program, který používá zcela nevhodný algoritmus, nebo velmi špatně pojmenované proměnné, nebo je zapsaný na dvě obrazovky úplně bez dekompozice,
• hodnocení X dostanou programy, u kterých jste se dobrovolně vzdali hodnocení (a to jasně formulovaným komentářem na začátku souboru, např. „Vzdávám se hodnocení.“),
• hodnocení C dostanou všechny ostatní programy, zejména ty, které kombinují dvě a více výrazné chyby zmiňované výše.

• na opravu budete mít týden,
• na opraveném programu nesmí selhat verity testy,
• testy budou nadále probíhat se stejnou kadencí jako během řádné doby k vypracování (pondělí, středa, pátek o 23:59).

• „s1/z₁“ – obdržíte známky za první sadu,
• „s1/op“ – termín pro odevzdání opravených řešení 1. sady,
• „s1/z₂“ – výsledné známky za první sadu,
• analogicky pro s2 a s3.

• známka A Vám vynese 5 bodů,
• známka B pak 2 body,
• známka X žádné body neskýtá,
• známka C je hodnocena -1 bodem.

• vložení nových řádků (prázdných nebo s komentářem), nebo
• doplnění komentáře na stávající prázdný řádek.

• proběhne v počítačové učebně bez přístupu k internetu nebo vlastním materiálům,
• k dispozici bude tato sbírka (bez vzorových řešení příkladů typu e a r) a skripta,
• budete moct používat textový editor nebo vývojové prostředí VS Code, standardní překladače jazyka C a odpovídající nástroje, překladač tiny a odpovídající virtuální stroj.

• čtvrtek 13.6. 9:00–13:00, 14:00–18:00,
• čtvrtek 20.6. 9:00–13:00, 14:00–18:00,
• čtvrtek 27.6. 9:00–13:00, 14:00–18:00.

• cvičení 4 (18.-22. března),
• cvičení 8 (15.-19. dubna),
• cvičení 12 (13.-17. května),

• 1/2 bodů získaných (ze všech příprav v dotčeném týdnu, nebo za jednotlivý příklad ze sady),
• 10 bodů z hodnocení bloku, do kterého opsaný příklad patří,
• 10 bodů (navíc k předchozím 10) z celkového hodnocení.

• Váš celkový zisk za přípravy v tomto týdnu je 4,5 bodu,
• Váš celkový zisk za první blok je 65 bodů,

• za bloky máte před penalizací 77, 62, 61, 64,
• v prvním bloku jste opsali domácí úkol,

• v prvním bloku 10 + 5, tzn. bodové zisky za bloky budou efektivně 62, 62, 61, 64,
• v celkovém hodnocení 10, tzn. celkový zisk 62 + 62 + 61 + 64 - 10 = 239, a budete tedy hodnoceni známkou F.

1. onomu vyššímu jazyku (v tomto kurzu to bude ten nejnižší z nich – jazyk C – abychom co nejvíce zmenšili vzdálenost, kterou musíme překlenout) tak
2. výpočetnímu stroji (který odpovídá procesoru a paměti), který bude výpočty našich programů realizovat.

1. šestnácti registrů, každý o šířce 16 bitů:
   • registr rv (return value),
   • registry l1 až l7 (local),
   • registry t1 až t6 (temporary),
   • registry bp a sp,
2. speciálního 16bitového registru pc (program counter),
3. 64 KiB paměti adresované po slabikách (bajtech) – adresa je tedy 16bitové celé číslo (bez znaménka), které přesně určuje právě jednu paměťovou buňku, přitom každá taková buňka obsahuje celé číslo v rozsahu 0 až 255.

1. z adresy uložené v registru pc se načtou dvě šestnáctibitová slova – hi z adresy pc a lo z adresy pc + 2 – která kódují jednu instrukci,
2. instrukce je strojem dekódována a provedena:
   • slovo hi kóduje operaci (vyšší slabika), cílový registr a první registrový operand,
   • slovo lo kóduje přímý (immediate) operand, nebo druhý registrový operand (v nejvyšší půlslabice),
   • provede se efekt instrukce (tento efekt samozřejmě závisí jak na operaci, tak na operandech) – obvykle je součástí tohoto efektu změna hodnoty uložené v registru pc,
3. nebyl-li výpočet zastaven, pokračuje bodem 1.

1. speciální operace:
   • práce se zásobníkem (push, pop),
   • nastavení registru na konstantu (put),
   • nastavení registru na hodnotu z jiného registru (copy),
   • znaménkové rozšíření bajtu (sext),
2. operace pro práci s pamětí:
   • kopírování dat z paměti do registru (ld, ldb),
   • kopírování z registru do paměti (st, stb),
3. aritmetické operace:
   • aditivní – bez rozlišení znaménkovosti (add, sub),
   • násobení mul,
   • dělení se znaménkem (sdiv, smod),
   • dělení bez znaménka (udiv a umod),
4. operace pro srovnání dvou hodnot:
   • rovnost (eq, ne),
   • znaménkové ostré nerovnosti (slt, sgt),
   • znaménkové neostré nerovnosti (sle, sge),
   • bezznaménkové ostré (ult, ugt), a konečně
   • bezznaménkové neostré (ule, uge),
5. bitové operace:
   • logické operace and, or a xor aplikované po bitech,
   • bitové posuvy shl (levý), shr (pravý) a aritmetický sar,
6. řízení toku:
   • nepodmíněný skok jmp,
   • podmíněné skoky jz (jump if zero) a jnz (if not zero),
   • volání a návrat z podprogramu (call, ret),
7. ovládaní stroje:
   • halt zastaví výpočet,
   • asrt zastaví výpočet s chybou, je-li operand nulový.

1. pc je aktuální hodnota programového čítače,
2. regs je seznam 16 celých čísel, každé v rozsahu 0 až 65535, jenž reprezentují hodnoty uložené v registrech,
3. mem je seznam 65536 celých čísel, každé v rozsahu 0 až 255, přitom číslo uložené na indexu i reprezentuje paměťovou buňku s adresou i.

• uloží slovo ze vstupního registru
• na adresu, která vznikne jako součet přímého operandu a hodnoty ve výstupním registru (jedná se zde o výjimečné použití výstupního registru jako vstupní hodnoty).

    if opcode == 0x03: # stb 
        mem[ addr ] = regs[ r_1 ]  % 256

    if opcode == 0x04: # st 
        mem[ addr + 0 ] = regs[ r_1 ] // 256
        mem[ addr + 1 ] = regs[ r_1 ]  % 256

• vypočte adresu jako součet přímého operandu a hodnoty ve vstupním registru,
• z vypočtené adresy načte slovo a uloží ho do výstupního registru.

    if opcode == 0x01: # ldb 
        regs[ r_out ] = mem[ addr ]

    if opcode == 0x02: # ld 
        regs[ r_out ] = mem[ addr ] * 256 + mem[ addr + 1 ]

• operace z kategorie 1 použije přímý operand jako levý a vstupní registr jako pravý,
• v kategorii 2 je tomu naopak, levý operand je vstupní registr a pravý operand je přímý,
• konečně kategorie 3 pracuje se dvěma vstupními registry (přímý operand nemá).

        if ( dividend > 0 ) != ( divisor > 0 ) and rem != 0: 
            rem -= divisor
        if quot < 0 and rem != 0:
            quot += 1

        return ( quot if op == 0x5 else rem ) % 65536 

            if op == 0xa: 
                bit_r = bit_1 == 1 and bit_2 == 1
            if op == 0xb:
                bit_r = bit_1 == 1 or  bit_2 == 1
            if op == 0xc:
                bit_r = ( bit_1 == 1 ) != ( bit_2 == 1 )

            result += bit_r * 2 ** idx 

        return result 

    assert False 

    sig_1 = as_signed( arg_1, 16 ) 
    sig_2 = as_signed( arg_2, 16 )

    if op == 0x0: result = arg_1 == arg_2 
    if op == 0xf: result = arg_1 != arg_2

    if op == 0x1: result = arg_1 <  arg_2 
    if op == 0x2: result = arg_1 <= arg_2
    if op == 0x3: result = arg_1 >  arg_2
    if op == 0x4: result = arg_1 >= arg_2

    if op == 0xa: result = sig_1 <  sig_2 
    if op == 0xb: result = sig_1 <= sig_2
    if op == 0xc: result = sig_1 >  sig_2
    if op == 0xd: result = sig_1 >= sig_2

    return 1 if result else 0 

    while status == CONT: 
        pc, status = step( pc, regs, mem )

    return status == HALT 

def read_program( filename: str ) -> list[ int ]: 
    mem = [ 0 for i in range( 65536 ) ]
    index = 0

    with open( filename, 'r' ) as file: 
        for line in file.readlines():
            if line[ 0 ] == ';':
                break
            for word in line.rstrip().replace( "'", '' ).split( ' ' ):
                for hex_nibble in word:
                    write_nibble( mem, index, FROM_HEX[ hex_nibble ] )
                    index += 1

    return mem 

1. xxx

1. fib – n-té fibonacciho číslo (mod )
2. adder – dvouslovná sčítačka (32b)
3. gcd – euklidův algoritmus
4. prime – rozhodování prvočíselnosti
5. popcnt – spočítat jedničky ve slově
6. perfect – součet dělitelů

1. reverse – otočení bitů ve slově
2. hamming – hammingova vzdálenost slov
3. packed – sečtení dvou dvojic po složkách
4. bitswap – prohození dvou bitů ve slově
5. collatz – počítání kroků iterovaného výpočtu
6. xxx

1. celé číslo bez znaménka v rozsahu – pak sekvence bitů přímo odpovídá binárnímu zápisu tohoto čísla,
2. jako celé číslo se znaménkem v rozsahu , a to tak, že:
   1. je-li nejvyšší bit nastaven na 1, ,
   2. jinak

Podmínku z bodu (a) můžeme také chápat jako ⟦n ≥ 2ᵇ⁻¹⟧.

• (nebo 0–ffff v šestnáctkovém zápisu) pro reprezentaci bez znaménka,
• (nebo -8000 až 7fff šestnáctkově) pro reprezentaci se znaménkem.

• jmp addr způsobí, že výpočet bude pokračovat od adresy addr – bez ohledu na aktuální stav registrů; adresu můžeme (a typicky budeme) zadávat jako symbol (jméno návěstí – viz též část B.3),
• jz reg, addr (jump if zero) nejprve ověří, je-li hodnota registru reg nulová – pokud ano, provede skok stejně jako jmp addr, v případě opačném pokračuje na další instrukci bez jakéhokoliv dalšího efektu,
• jnz reg, addr (jump if not zero) se chová stejně, ale skok provede pouze je-li hodnota uložená v reg nenulová.

data:   ;  l1  l2  l3  →  rv 
    .word  3,  4,  5,     1
    .word  1,  1,  1,     1
    .word  1,  1,  3,     0
    .word  2,  3,  1,     0
    .word -1,  0

check: 
    ld   l7, 0x24   → t1
    eq   rv, t1     → t1
    asrt t1
    add  l7, 2      → l7
    jmp  test

.trigger set _tc_expect_ 4 
.trigger inc _tc_

solution: ; zde začíná řešení 

    add l1, l3 → t1 
    sgt t1, l2 → t2
    and rv, t2 → rv

    add l2, l3 → t1 
    sgt t1, l1 → t2
    and rv, t2 → rv

data:   ; input, expect 
    .word     1,      1
    .word     2,      2
    .word     3,      6
    .word     4,     24
    .word    -1,      0

check: 
    add  l7, 2      → l7
    ld   l7, 0x10   → t1
    eq   rv, t1     → t1
    asrt t1
    add  l7, 2      → l7
    jmp  test

.trigger set _tc_expect_ 4 
.trigger inc _tc_

solution: ; zde začíná řešení 

    jmp check 

1. spočítat, po kolika aplikacích funkce f na vstup je poprvé výsledkem jednička a
2. zjistit nejvyšší mezivýsledek, který při výpočtu vznikl.

1. fib – lokální proměnné, cyklus
2. prime – aritmetika a rozsah číselných hodnot

1. gcd – euklid podruhé
2. rand – generování pseudonáhodných čísel
3. collatz – počítání kroků iterovaného výpočtu
4. packed – součet n-tic po složkách
5. popcnt – počet nenulových cifer při daném základu
6. hamming – hammingova vzdálenost při daném základu

1. palindrome – binární palindrom
2. largest – nejvyšší číslice při daném základu
3. factors – rozklad na prvočinitele
4. primes – rozklad na prvočinitele podruhé
5. transpose – překlopení bitové matice
6. balanced – vyvážená trojková soustava

1. digits – ciferný součet při daném základu
2. rotate – bitová rotace slova

• unsigned – celé číslo v rozsahu 0 až 65535,⁹
• int – celé číslo v rozsahu -32768 do 32767,¹⁰
• bool – celé číslo, 0 nebo 1, které typicky reprezentuje pravdivostní hodnotu – 0 pro false, 1 pro true,
• signed char – celé číslo v rozsahu -128 až 127,
• unsigned char – celé číslo v rozsahu 0 až 255,
• char – typ se stejným rozsahem jako jeden z předchozích dvou (který z nich je určeno implementací), ale přesto z pohledu kontroly typů od obou odlišný.

• místo jednoho bajtu si pamatuje hodnotu (která může mít potenciálně složitou vnitřní strukturu, i když takové zatím neumíme v jazyce C sestrojit),
• místo adresy má identitu – objekt můžeme „uchopit“ a pracovat s ním – obvykle tak, že tento objekt svážeme s proměnnou.

• e₁, e₂ … eₙ výrazy,
• var jméno proměnné,
• lit číselný literál (konstanta),

1. lit (konstanta) je výraz,
2. var (jméno proměnné) je výraz,
3. použití aritmetického operátoru (binární v infixovém zápisu, unární v prefixovém):
   • e₁ + e₂, e₁ - e₂,
   • e₁ * e₂, e₁ / e₂, e₁ % e₂ (modulo)
   • unární mínus -e₁,
4. relační operátory:
   • e₁ == e₂ (rovnost), e₁ != e₂ (nerovnost)
   • e₁ <= e₂, e₁ >= e₂, e₁ < e₂, e₁ > e₂
5. bitové logické operace a posuvy:
   • binární e₁ & e₂ (and), e₁ | e₂ (or), e₁ ^ e₂ (xor),
   • unární ~e₁ – bitová negace,
   • bitové posuvy zapisujeme e₁ >> e₂, e₁ << e₂,
6. operátory přiřazení (pozor na změnu oproti jazyku Python – v jazyce C je přiřazení výraz, nikoliv příkaz):
   • jednoduché var = e₁,
   • složené var += e₁, var -= e₁,
   • dále var *= e₁, var /= e₁, var %= e₁,
   • s bitovým posuvem var <<= e₁, var >>= e₂,
   • s bitovou operací var &= e₁, var ^= e₁, var |= e₁,
7. operátory zvýšení a snížení proměnné o jedničku:
   • prefixové ++var, --var,
   • postfixové var++, var--,
8. operátor čárka, e₁, e₂,
9. booleovské logické operace:
   • binární e₁ && e₂ (and), e₁ || e₂ (or),
   • unární !e₁,
   • ternární e₁ ? e₂ : e₃,

1. Výraz lit se vyhodnotí přímo na číselnou hodnotu zapsanou ve zdrojovém kódu. Například vyhodnocení výrazu 7 do registru rv se realizuje instrukcí put 7 → rv.
2. Výraz var se vyhodnotí na hodnotu, která je v momentě vyhodnocení tohoto výrazu uložena v objektu svázaném s proměnnou var. Prozatím uvažujeme pouze situace, kdy je objekt svázaný s var uložen přímo v registru. Je-li např. var uloženo v l1, vyhodnocení výrazu var do registru rv realizujeme instrukcí copy l1 → rv.
3. Uvažme nyní výraz tvaru e₁ + e₂. Víme, že e₁ a e₂ popisují nějaké hodnoty. Abychom mohli vyčíslit hodnotu e₁ + e₂, budeme nejprve potřebovat tyto hodnoty. Na to použijeme dočasné registry – vyhodnocení e₁ + e₂ do rv bude vypadat takto:
   1. vyhodnoť e₁ do registru t₁,
   2. vyhodnoť e₂ do registru t₂,
   3. proveď add t₁, t₂ → rv.
   Musíme samozřejmě zabezpečit, že výpočet e₂ nepřepíše registr t₁ – jak přesně se toho dosáhne budeme zkoumat později.¹⁶ Analogicky se vypočtou ostatní aritmetické, bitové, atd. operátory (k hodnotám s/bez znaménka a operacím dělení se ještě vrátíme).
4. Výrazy tvaru var = e₁ mají krom hodnoty také vedlejší efekt – zápis do objektu svázaného s proměnnou var. Jejich realizace vypadá takto – vyhodnocujeme do registru rv, objekt svázaný s var nechť žije v l1:
   1. vyhodnoť e₁ do registru rv
   2. proveď copy rv → l1.
   Všimněte si, že hodnota e₁ je zároveň hodnotou celého výrazu, a zůstává uložená v registru rv, jak bylo požadováno.
5. Složené přiřazení var += e₁ je analogické, pouze je operaci copy předřazena příslušná aritmetická nebo logická operace:¹⁷
   1. vyhodnoť e₁ do registru t₁
   2. proveď add t1, l1 → rv,
   3. proveď copy rv → l1.
   Výrazy zvýšení a snížení o jedničku jsou analogické, liší se pouze ve výsledné hodnotě. Prefixové verze, ++var, --var jsou pouze syntaktické zkratky pro var += 1 resp. var -= 1, ale postfixové se liší – vyhodnocení var++ do rv proběhne takto (var je svázáno s l1):
   1. proveď copy l1 → rv,
   2. proveď add l1, 1 → l1.
   Hodnota výrazu var++ je tedy původní hodnota var, předtím, než bylo provedeno zvýšení proměnné o jedničku.
6. Výraz e₁, e₂ představuje „zapomenutí hodnoty“ výrazu e₁ – výraz e₁ je proveden pouze pro svoje vedlejší efekty (např. výše uvedené přiřazení). Vyhodnocení e₁, e₂ do registru rv lze realizovat např. takto:
   1. vyhodnoť e₁ do rv,
   2. vyhodnoť e₂ do rv.
7. Zbývá zatím nejsložitější typ výrazů, a to jsou booleovské logické operace. XXX

1. var + 1 se vypočte XXX

• výraz + středník
• složený příkaz
• if, else
• for
• while
• break
• continue

1. jména typu, v tomto případě znaménkového celočíselného typu int,
2. neprázdného seznamu deklarovaných jmen (oddělených čárkou), které mohou být doplněny tzv. deklarátory (označují např. ukazatele: uvidíme je v pozdější ukázce),
3. volitelného inicializátoru, který popisuje počáteční hodnotu proměnné.

    int a = 1, b = 1; 

1. klíčové slovo for,
2. hlavička cyklu, uzavřená v kulatých závorkách,
   1. inicializační příkaz (výraz, deklarace proměnné, nebo prázdný příkaz) je vždy ukončen středníkem a provede se jednou před začátkem cyklu; deklaruje-li proměnné, tyto jsou platné právě po dobu vykonávání cyklu,
   2. podmínka cyklu (výraz nebo prázdný příkaz) je opět vždy ukončena středníkem a určuje, zda se má provést další iterace cyklu (vyhodnotí-li se na true),
   3. výraz iterace (výraz, který není ukončen středníkem), který je vyhodnocen vždy na konci těla (před dalším vyhodnocením podmínky cyklu),
3. tělo cyklu (libovolný příkaz, často složený).

int main() /* demo */ 
{

    return 0; 
}

• , šestnáctkově 0xfa5fff9,
• omezeno na 16 bitů 0xfff9, desítkově tedy 65529.

    while ( divisor <= sqrt_uint_max && 
            divisor * divisor <= number )
    {

        ++ divisor; 
    }

    return true; 
}

int main() /* demo */ 
{
    assert( is_prime( 2 ) );
    assert( is_prime( 3 ) );
    assert( is_prime( 5 ) );
    assert( is_prime( 13 ) );
    assert( is_prime( 29 ) );
    assert( is_prime( 97 ) );
    assert( is_prime( 619 ) );

    assert( !is_prime( 1 ) ); 
    assert( !is_prime( 4 ) );
    assert( !is_prime( 6 ) );
    assert( !is_prime( 8 ) );
    assert( !is_prime( 68 ) );
    assert( !is_prime( 77 ) );
    assert( !is_prime( 81 ) );
    assert( !is_prime( 323 ) );
    assert( !is_prime( 36863u ) );

    assert( is_prime( 65521u ) ); 
}

unsigned rand_hi( unsigned hi, unsigned lo ) 
{
    return 0;
}

unsigned rand_lo( unsigned hi, unsigned lo ) 
{
    return 0;
}

    return 0; 
}

    return 0; 
}

    return 0; 
}

    return 0; 
}

    return 0; 
}

1. cycle – hledání délky cyklu v permutaci
2. pow – algoritmus pro celočíselné mocnění

1. cellular – buněčný automat nad slovem
2. permute – jsou dvě slova vzájemnou permutací v base 3
3. rotate – jsou dvě slova vzájemnou rotací
4. fractal – -tý člen fraktální posloupnosti
5. palindrome – nejmenší počet palindromových segmentů
6. sat – splnitelnost malé výrokové formule

1. power – modulární mocnění
2. squares – součty druhých mocnin
3. knight – skákání koněm
4. bezout – rozšířený Euklidův algoritmus
5. xxx
6. xxx

• typ₀ je tzv. návratový typ – může být prozatím pouze jeden z již známých typů (int, unsigned, …),
• jméno₀ je název zaváděného podprogramu,
• typ₁ … typₙ jsou typy jednotlivých parametrů,
• jméno₁ … jménoₙ jsou jména parametrů,
• příkaz₁ … příkazₘ tvoří tělo podprogramu.

• typ výrazu expr₁ je možné implicitně převést na typ₁,
• typ expr₂ na typ typ₂, atd., až exprₙ na typₙ.

1. Pro každý formální parametr je vytvořen objekt odpovídajícího typu; uvnitř těla podprogramu pak jména formálních parametrů pojmenovávají právě tyto objekty.
2. Výrazy expr₁ až exprₙ jsou vyhodnoceny na hodnoty (v blíže neurčeném pořadí!) a každá takto získaná hodnota je zapsána do příslušného objektu z předchozího bodu.
3. Řízení je předáno tělu podprogramu (vzniká při tom mimo jiné nový rozsah platnosti jmen).
4. Hodnota celého výrazu funcall je pak určena prvním spuštěným příkazem return uvnitř těla. Tento příkaz zároveň předá řízení zpátky volajícímu podprogramu.

1. vyhodnotí výraz expr a jeho hodnotu vrátí volajícímu (viz předchozí podsekce),
2. ukončí vykonávání podprogramu a předá řízení volajícímu.

int main() /* demo */ 
{
    assert( find_period( 1 ) == 3 );
    assert( find_period( 5 ) == 3 );
    assert( find_period( 14 ) == 13 );

    return 0; 
}

unsigned permute( unsigned n ) 
{
    if ( n < 13 )
        return n / 3 * 3 + ( n + 1 ) % 3;
    else
        return n / 13 * 13 + ( n + 1 ) % 13;
}

    if ( exp == 1 ) 
        return n;

int pow_iter( int n, int exp ) 
{
    assert( exp >= 1 );

int main() /* demo */ 
{
    assert( pow_rec( 1, 2 ) == 1 );
    assert( pow_rec( 2, 1 ) == 2 );
    assert( pow_rec( 2, 2 ) == 4 );
    assert( pow_rec( 2, 3 ) == 8 );
    assert( pow_rec( 3, 2 ) == 9 );

    for ( int i = 0; i < 32; ++i ) 
        for ( int j = 1; j < ( i < 8 ? 5 : 4 ); ++j )
            assert( pow_rec( i, j ) == pow_iter( i, j ) );
}

• 0 v případě, že formuli při daném val a mask není možné splnit,
• 1 v případě, že již splněná je (a na proměnných, které jsou v mask zakázané, již nezáleží),
• nebo -1 v případě, že výsledek závisí na bitech, které jsou v mask nulové.

int evaluate( unsigned n, unsigned mask, unsigned val ); 

data: 
      a,    b  →  gcd( a, b )
    .word       1,    1,     1
    .word       2,    2,     2
    .word      18,   15,     3
    .word      20,   30,    10
    .word      -1

    push t1 
    call bezout
    pop  t1

    .trigger set _tc_expect_ 4 
    .trigger inc _tc_

    ld   t1, data     → l3 
    ld   t1, data + 2 → l4
    ld   t1, data + 4 → l5

    mul  l3, rv → rv 
    mul  l4, l1 → l1
    add  l1, rv → rv
    eq   rv, l5 → rv
    asrt rv

    add  t1, 6 → t1 
    jmp  .main.loop
.main.leave:
    halt

• podobně jako adresa je (strojové) slovo, ukazatel je hodnota,
• platný ukazatel musí „ukazovat“ na platný objekt,
• ukazatel je reprezentován, stejně jako adresa, celým číslem bez znaménka (o pevné bitové šířce dané architekturou stroje).

1. divmod – výstupní parametry
2. xxx

1. rand – náhodná čísla podruhé
2. zero – počet nul a index té nejlevější
3. xxx
4. xxx
5. xxx
6. xxx

1. xxx
2. xxx
3. xxx
4. xxx
5. xxx
6. xxx

• libovolný operand operátoru čárka (nezávisle),
• e₁ a e₂ ve výrazu ternary ≡ e₀ ? e₁ : e₂ – pak je typ výrazu ternary jako celku také void,²²
• e₁ ve výrazu přetypování ( void ) e₁.

1. Většina podvýrazů tvoří r-kontexty, tzn. takové, které očekávají hodnotu – např. operandy aritmetických nebo relačních operátorů, parametry předávané podprogramu, pravý operand operátoru přiřazení, atd. Je-li nějaký podvýraz vyhodnocen na objekt v r-kontextu, je z tohoto objektu navíc přečtena hodnota a výsledkem výrazu je až tato hodnota.
2. Některé podvýrazy jsou ale l-kontextem a v takovém případě se vyhodnocení zastaví určením objektu a čtení hodnoty ze získaného objektu se neprovede. Jedná se zejména o levý operand přiřazovacího operátoru (odtud také název l-kontext).

1. Výraz *expr₁, tzv. dereferenci, lze použít pouze vyhodnotí-li se expr₁ na platný ukazatel (jedná-li se o ukazatel neplatný, program je chybný a jeho chování není určeno), a vyhodnotí se na objekt (l-hodnotu), který je tímto ukazatelem popsán. Je-li výraz expr₁ typu T *, je výraz *expr₁ typu T.
2. Výraz &expr₁ lze použít jen tehdy, vyhodnotí-li se expr₁ na objekt (je l-hodnotou) a výsledkem je ukazatel na tento objekt. Unární operátor & se anglicky nazývá „address of“, nicméně jeho výsledkem není striktně vzato adresa.²⁴ Je-li výraz expr₁ typu T, je výraz &expr₁ typu T *.
3. expr₁ = expr₂ (jedná se o zobecnění již zavedeného var = expr₂) lze použít, vyhodnotí-li se expr₁ na objekt (tzn. expr₁ popisuje l-hodnotu). Efektem tohoto výrazu je, že hodnota uložená v takto popsaném objektu se přepíše na hodnotu, kterou získáme vyhodnocením výrazu expr₂.

1. a_float – aritmetika s plovoucí desetinnou čárkou,
2. b_depth – práce s implicitním stromem,
3. c_tree – predikáty na stromech,
4. d_enum – číslování množin celých čísel,
5. e_xxx – ???
6. f_xxx – ???

• mantisa nebude používat implicitní bit, tzn. v nenulovém normalizovaném čísle bude mít vždy na nejvyšší pozici jedničku,
• nebudeme uvažovat subnormální čísla, nekonečna ani hodnoty NaN (vstupem jsou tedy vždy normalizovaná konečná čísla),
• budeme předpokládat, že nedojde k přetečení (tzn. výsledek je vždy možné reprezentovat),
• zaokrouhlovat budeme vždy pouze ořezáním, tzn. směrem k nule,
• prohodíme mantisu a exponent,²⁶ tzn. od nejvyššího bitu je nejprve znaménkový bit (1 = záporné, 0 = kladné), následuje 10 bitů mantisy a 5 bitů exponentu.

1. vstupní hodnoty rozeberte na znaménkový bit, mantisu a exponent,
2. podle rozdílu exponentů zarovnejte mantisy „pod sebe“, tzn. tak, aby -tý bit jedné i druhé mantisy odpovídal -tému řádu; posuvy mantis provádějte tak, abyste zachovali 15 bitů přesnosti (přesto se v tomto kroku může stát, že některé bity vstupu ztratíme, např. při výpočtu 2²⁷⁰ + 2⁻⁸),
3. srovnejte znaménkové bity a zarovnané mantisy a podle potřeby proveďte součet nebo rozdíl a nastavte výsledný znaménkový bit (při sčítání nezapomeňte na případný přenos),
4. výsledek normalizujte (nejvyšší bit výsledné mantisy musí být jedna) – v tomto kroku dostanete výsledný exponent,
5. složte výsledek z vypočtené mantisy, exponentu a znaménkového bitu.

1. získáme znaménkové bity s₁ = 1, s₂ = 0,
2. mantisa m₁ = 0x200, m₂ stejně tak,
3. abychom dosáhli potřebné přesnosti, mantisy posuneme o 5 bitů doleva, tzn. dostaneme v obou případech 0x4000,
4. exponenty jsou kódovány jako e₁ = 0x10 a e₂ = 0x11 (tyto hodnoty značí „absolutní“ exponenty 1 a 2), jejich rozdíl je tedy 1 ve prospěch e₂ a jako prozatímní exponent výsledku si proto poznačíme e₀ = e₂,
5. mantisu m₁ posuneme o jeden bit doprava: m₁' = 0x2000,
6. protože znaménkové bity jsou různé, budeme odečítat – abychom předešli přetečení, odečítáme vždy menší číslo od většího, tzn. m₀ = m₂ - m₁' = 0x4000 - 0x2000 = 0x2000,
7. znaménkový bit výsledku bude jistě s₀ = 0,
8. první nenulový bit výsledné mantisy m₀ je na druhé nejvýznamnější pozici, ale normalizace vyžaduje, aby byl nenulový nejvyšší bit – proto m₀ posuneme o jednu pozici doleva a e₀ o jedničku snížíme,
9. mantisu ořízneme na výsledných 11 bitů přesnosti a z takto získaných s₀, m₀ a e₀ složíme hledané x₀.

• volání tree_get_child( t, n, i ) je přípustné pouze
• platí-li i < tree_child_count( t, n ).