Clausal Language (ver. 5.81.19, by P.J. Voda, J. Komara, J. Kluka)

3. CVIČENIE Z PREDMETU ÚVOD DO DEKLARATÍVNEHO PROGRAMOVANIA 2011/2012

ČASŤ B

http://ii.fmph.uniba.sk/cl/courses/1-AIN-505-udp/1112ls/ex/ex03.zip

Dátum: 27. 2. 2012

Odporúčaná verzia CL: 5.81.20

WWW stránka predmetu: http://dai.fmph.uniba.sk/courses/udp

Kontakt: udp(zavináč)lists.dai.fmph.uniba.sk

Úvodná poznámka. Toto cvičenie je venované priraďujúcim diskrimináciám (ex03a) a simulácii cyklov chvostovou rekurziou (ex03b).

Literatúra.

[1] J. Kľuka. Prednášky z Úvodu do deklaratívneho programovania LS 2011/2012.

http://ii.fmph.uniba.sk/cl/courses/1-AIN-505-udp/1112ls/udp-screen.pdf

[2] D. Guller. Poznámky k prednáškam z CL.

[3] J. Komara and P. J. Voda. Metamathematics of Computer Programming. 2001.

Poznámka. Nadpisy sú číslované podľa [1].

Preskočte nasledujúce komponenty po nadpis „CVIČENIE“.

? = 0

C V I Č E N I E

7. SIMULÁCIA CYKLOV CHVOSTOVOU REKURZIOU

Poznámka. Podrobnejší návod na riešenie nasledujúcich úloh nájdete napríklad v prednáškach [1].

Úlohy označené hviezdičkou $*$ riešte po vyriešení všetkých neoznačených úloh.

7.1 Simulácia while cyklu

Výpočet faktoriálu while cyklom. Funkciu $Fact (n) \equiv n!$

0! = 1

(n + 1)! = (n + 1) \cdot n!

vypočítame pomocou pascalovského while cyklu nasledovne:

    f := 1;                  }  Fact
    while n <> 0 do begin   -
        f := f*n;            |
        n := n-1             |- While_fact
    end;                     |
    Result := f             -

Úloha. Faktoriál simuláciou while cyklu. Simulujte uvedený while cyklus chvostovorekurzívnou funkciou $While_fact (n, f)$ a použite ju na zadefinovanie funkcie $Fact (n) \equiv n!$ . Pomocný argument $f$ nazývame akumulátor.

Ako je naznačené vyššie, funkcia $While_fact$ počíta iba cyklus a vrátenie výsledku.

Hlavná funkcia $Fact$ inicializuje akumulátor $f$ vhodným volaním funkcie $While_fact$ .

Invariant:

While_fact (n, f) = f \cdot n!

While_fact (n, f) = ?

n! = ?

Fact_test = 0!, 1!, 2!, 3!, 4!, 5!, 6!, 7!, 0

Fact_result = 1, 1, 2, 6, 24, 120, 720, 5040, 0

Úloha. Umocnenie simuláciou while cyklu. Naprogramujte umocnenie pomocou simulácie while cyklu.

a) Do nasledujúcej poznámky vpíšte fragment pascalovského programu, ktorý vypočíta umocnenie do akumulátora $e$ , podobne ako pri faktoriáli.

e := ...;
while ... do begin
    ...
end;
Result := e

b) Zadefinujte chvostovorekurzívnu funkciu $While_exp (x, y, e)$ , ktorá simuluje váš while cyklus, ale nie inicializáciu akumulátora.

Invariant:

While_exp (x, y, x^{z}) = x^{y + z}

While_exp (x, y, e) = ?

c) Funkcia $Exp (x, y) \equiv x^{y}$ odštartuje simuláciu while cyklu s vhodnou začiatočnou hodnotou akumulátora $e$ .

x^{y} = ?

Exp_test = (0^{0}, 1^{0}, 2^{0}, 5^{0}), (0^{1}, 1^{1}, 2^{1}, 5^{1}), (0^{10}, 1^{10}, 2^{10}, 5^{10}), 0

Exp_result = (1, 1, 1, 1), (0, 1, 2, 5), (0, 1, 1024, 9765625), 0

7.2 Efektívny výpočet Fibonacciho postupnosti

Efektívny výpočet členov Fibonacciho postupnosti while cyklom. Funkciu $Fib (n) \equiv {fib}_{n}$ pre $n$ -tý člen Fibonacciho postupnosti

{fib}_{0} = 0

{fib}_{1} = 1

{fib}_{n + 2} = {fib}_{n} + {fib}_{n + 1}

môžeme efektívne vypočítať pomocou while cyklu s dvoma akumulátormi $m$ , $d$ , v ktorých si pamätáme dva po sebe nasledujúce členy postupnosti:

    if n = 0 then                            -
        Result := 0                           |
    else begin                                |_ Fib_efficient
        n := n - 1; { !! }                    |
        m := 0; { fib(0) }                    |
        d := 1; { fib(1) }                   -
        while n <> 0 do begin                -
            { m = fib(i) & d = fib(i+1) }     |
            m1 := d;                          |
            d1 := m+d;                        |
            m := m1; d := d1;                 |- While_fib
            { m = fib(i+1) & d = fib(i+2) }   |
            n := n-1                          |
        end;                                  |
        Result := d                          -
    end

Úloha. Efektívny výpočet členov Fibonacciho postupnosti simuláciou while cyklu.

a) Simulujte while cyklus z predchádzajúcej poznámky chvostovorekurzívnu funkciou $While_fib (n, m, d)$ . Úvodný test a inicializáciu premenných zatiaľ neberte do úvahy.

Invariant:

While_fib (n, {fib}_{i}, {fib}_{i + 1}) = {fib}_{n + i + 1}

While_fib (n, m, d) = ?

b) Naprogramujte funkciu $Fib_efficient (n) \equiv {fib}_{n}^{efficient}$ , ktorá vykoná úvodný test pascalovského programu a spustí simuláciu while cyklu so správne inicializovanými hodnotami premenných $n$ , $a$ , $b$ .

{fib}_{n}^{efficient} = ?

Fib_efficient_test = {fib}_{0}^{efficient}, {fib}_{1}^{efficient}, {fib}_{2}^{efficient}, {fib}_{3}^{efficient}, {fib}_{4}^{efficient}, {fib}_{5}^{efficient}, {fib}_{6}^{efficient}, {fib}_{7}^{efficient}, {fib}_{8}^{efficient}, 0

Fib_efficient_result = {fib}_{0}, {fib}_{1}, {fib}_{2}, {fib}_{3}, {fib}_{4}, {fib}_{5}, {fib}_{6}, {fib}_{7}, {fib}_{8}, 0

$*$ Úloha. Podobne ako v predchádzajúcej úlohe zadefinujte efektívnu verziu $F1_efficient (n) \equiv F_{1}^{efficient} (n)$ nasledujúcej funkcie $F_{1} (n)$ simuláciou while cyklu.

F_{1} (0) = 0

F_{1} (1) = 1

F_{1} (2) = 2

F_{1} (n + 3) = F_{1} (n) + F_{1} (n + 1) + F_{1} (n + 2)

a) Do nasledujúcej poznámky vpíšte pascalovský program, ktorý počíta funkciu $F_{1}$ while cyklom. Výpočet je podobný výpočtu Fibonacciho postupnosti. Program si pamätá 3 po sebe nasledujúce členy postupnosti v akumulátoroch $a$ , $b$ , $c$ .

if n = 0 then
    ...
else if n = 1 then
    ...
else begin
    n := ...;
    a := ...; { F1(0) }
    b := ...; { F1(1) }
    c := ...; { F1(2) }
    while ... do begin
        { a = F1(i) & b = F1(i+1) & c = F1(i+2) }
        ...
        { a = F1(i+1) & b = F1(i+2) & c = F1(i+3) }
    end;
    Result := c
end

b) Simulujte while cyklus funkciou ${While_f}_{1} (n, a, b, c)$ .

Invariant:

{While_f}_{1} (n, F_{1} (i), F_{1} (i + 1), F_{1} (i + 2)) = F_{1} (n + i + 2)

{While_f}_{1} (n, a, b, c) = ?

c) Vo funkcii $F1_efficient (n) \equiv F_{1}^{efficient} (n)$ ošetrite okrajové prípady a odštartujte cyklus so správne inicializovanými premennými.

F_{1}^{efficient} (n) = ?

F1_efficient_test = F_{1}^{efficient} (0), F_{1}^{efficient} (1), F_{1}^{efficient} (2), F_{1}^{efficient} (3), F_{1}^{efficient} (4), F_{1}^{efficient} (5), F_{1}^{efficient} (6), F_{1}^{efficient} (7), F_{1}^{efficient} (8), F_{1}^{efficient} (9), 0

F1_efficient_result = F_{1} (0), F_{1} (1), F_{1} (2), F_{1} (3), F_{1} (4), F_{1} (5), F_{1} (6), F_{1} (7), F_{1} (8), F_{1} (9), 0

7.3 Simulácia for cyklu

Faktoriál simuláciou for cyklu. Faktoriál môžeme počítať aj pomocou pascalovského for cyklu:

    f := 1;                       } Fact1
    for i := 1 to n do begin     -
        f := f*i                  |_ For_fact
    end;                          |
    Result := f                  -

Úloha. Faktoriál simuláciou for cyklu. Naprogramujte funkciu ${Fact}_{1}$ využitím pomocnej funkcie $For_fact$ .

a) Funkcia $For_fact$ simuluje for cyklus z predchádzajúcej poznámky. Zadefinujte ju spätnou rekuziou, pri ktorej rekurzívny argument $i$ rastie, kým neprekročí hranicu $n$ . Uvedomte si, že cyklus

    for i := 1 to n do begin TELO end

je ekvivalentný

    i := 1; while i <= n do begin TELO; i := i+1 end

For_fact (i, n, f) = ?

b) Funkcia ${Fact}_{1}$ spustí cyklus so správne inicializovanými premennými $i$ , $f$ a $n$ .

{Fact}_{1} (n) = ?

Fact1_test = {Fact}_{1} (0), {Fact}_{1} (1), {Fact}_{1} (2), {Fact}_{1} (3), {Fact}_{1} (4), {Fact}_{1} (5), {Fact}_{1} (6), {Fact}_{1} (7), 0

Fact1_result = 1, 1, 2, 6, 24, 120, 720, 5040, 0

$*$ Úloha. Zadefinujte efektívnu verziu $F2_efficient (n) \equiv F_{2}^{efficient} (n)$ nasledujúcej funkcie $F_{2} (n)$ simuláciou for cyklu.

F_{2} (0) = 0

F_{2} (1) = 1

F_{2} (n + 2) = F_{2} (n) + F_{2} (n + 1) + n

Funkciu $F_{2}$ môžeme efektívne vypočítať nasledujúcim for cyklom.

    if n = 0 then                          -
        Result := 0                         |
    else if n = 1 then                      |
        Result := 1                         |_ F2_efficient
    else begin                              |
        n := n - 2; { ! }                   |
        a := 0; { F2(0) }                   |
        b := 1; { F2(1) }                  -
        for i := 0 to n do begin           -
            { a = F2(i) & b = F2(i+1) }     |
            a1 := b;                        |
            b1 := a+b+i;                    |_ For_f2
            a := a1; b := b1;               |
            { a = F2(i+1) & c = F2(i+2) }   |
        end;                                |
        Result := b                        -
    end

Simulujte for cyklus pomocnou chvostovorekurzívnou funkciou ${For_f}_{2} (i, n, a, b)$ .

Invariant:

i ≦ n + 1 \to {For_f}_{2} (i, n, F_{2} (i), F_{2} (i + 1)) = F_{2} (n + 2)

Úvodné testy, inicializáciu premenných a štart cyklu implementujte v hlavnej funkcii $F2_efficient (n) \equiv F_{2}^{efficient} (n)$

{For_f}_{2} (i, n, a, b) = ?

F_{2}^{efficient} (n) = ?

F2_efficient_test = F_{2}^{efficient} (0), F_{2}^{efficient} (1), F_{2}^{efficient} (2), F_{2}^{efficient} (3), F_{2}^{efficient} (4), F_{2}^{efficient} (5), F_{2}^{efficient} (6), F_{2}^{efficient} (7), F_{2}^{efficient} (8), F_{2}^{efficient} (9), 0

F2_efficient_result = F_{2} (0), F_{2} (1), F_{2} (2), F_{2} (3), F_{2} (4), F_{2} (5), F_{2} (6), F_{2} (7), F_{2} (8), F_{2} (9), 0

$*$ Úloha. Zadefinujte efektívnu verziu $F3_efficient (n) \equiv F_{3}^{efficient} (n)$ funkcie $F_{3} (n)$ simuláciou for cyklu podobne ako v predchádzajúcej úlohe.

F_{3} (0) = 0

F_{3} (1) = 1

F_{3} (2) = 2

F_{3} (n + 3) = F_{3} (n) + F_{3} (n + 1) + F_{3} (n + 2) + n

Invariant:

i ≦ n + 1 \to {For_f}_{3} (i, n, F_{3} (i), F_{3} (i + 1), F_{3} (i + 2)) = F_{3} (n + 3)

{For_f}_{3} (i, n, a, b, c) = ?

F_{3}^{efficient} (n) = ?

F3_efficient_test = F_{3}^{efficient} (0), F_{3}^{efficient} (1), F_{3}^{efficient} (2), F_{3}^{efficient} (3), F_{3}^{efficient} (4), F_{3}^{efficient} (5), F_{3}^{efficient} (6), F_{3}^{efficient} (7), F_{3}^{efficient} (8), F_{3}^{efficient} (9), 0

F3_efficient_result = F_{3} (0), F_{3} (1), F_{3} (2), F_{3} (3), F_{3} (4), F_{3} (5), F_{3} (6), F_{3} (7), F_{3} (8), F_{3} (9), 0

Prémiová domáca úloha du03b. (2 body) Pravidlá pre prémiové domáce úlohy nájdete na http://dai.fmph.uniba.sk/courses/udp#pdu

Zistite presný počet rekurzívnych volaní potrebných na výpočet ${fib}_{200}$ podľa klasickej neefektívnej definície (viď vyššie úvod k časti 7.2). Vysvetlite, ako ste k tomuto počtu dospeli.

[CL] Poznámka. Pri výpočte odpovede pomocou CL narazíte na nasledovný problém: Hľadaný počet rekurzívnych volaní je viac ako 30-bitové číslo. Takéto čísla CL normálne zobrazuje v zmiešanom desiatkovo-dyadickom zápise (vysvetlíme neskôr). V iba desiatkovej sústave číslo zobrazíte použitím formátu $N$ podľa nasledujúceho príkladu:

    123456789*1000000001 = x:N