Berekening van de Orde Van een Algoritme De Orde van een algoritme is het aantal operaties dat wordt uitgevoerd bij uitvoering van dit algoritme Als men een schatting wil bekomen van de tijd nodig om een algoritme uit te voeren drukt men dit uit in functie van de input. De orde is een maat voor de complexiteit van een algoritme (onafhankelijk van hardware configuration of programming language) f(n) is O(g(n)) als er 2 positieve constanten K en n0 bestaan zodanig dat f(n) <= Kg(n)  n >= n0.

Voorbeeld 1 Een eenvoudige Scheme-functie: Operatoren : if -- null? Cons -- a-fun -- car my-map -- cdr (define (my-map a-fun a-list) (if (null? a-list) a-list (cons (a-fun (car a-list)) (my-map (cdr a-list)))))

Voorbeeld van functie a-fun : a-fun ==> (lambda (x) (+ x 2)) ==> 1 operatie a-fun ==> (lambda (x) (+ x (* 2 x))) ==> 2 operaties a-fun ==> (define (f x) (if (< x 0) 0 (+ x (f (- x 1))))) ==> het aantal operaties hangt van x af. Voor het voorbeeld zullen we ervan uitgaan dat a-fun uit 1 operatie bestaat.

Berekening van de Orde vanaf het Algoritme Input : waarde van a-list ‘() ‘(1) ‘(1 2) … ‘(1 2 … n) Aantal operaties : 2 7 + 2 ==> 9 7 + 7 + 2 ==> 16 … n * 7 + 2 Het aantal operaties groeit met n = lengte van de lijst ==> O(n)

Berekening van de Orde met Simulaties Als er geen pure iteratieve operatoren (bv. Do, repeat, maar ook append, reverse…) wordt gebruikt in de body van mijn Scheme functie, staat de Orde van het geassocieerd algoritme in direct verband met het aantal recursieve oproepen van de functie. => goed bekijk welke type functies worden gebruikt. Men kan in dit geval de Orde van het algoritme bepalen door enkel naar het aantal recursieve stappen ervan te gaan kijken

Ik voeg een counter toe en herschrijf my-map zodat de counter wordt geincrementeerd elke keer dat een recursieve oproep is gedaan. (define counter 0) (define (my-map a-fun a-list) (define (recur a-list) (set! counter (+ counter 1)) (if (null? a-list) a-list) (cons (a-fun (car a-list)) (recur (cdr a-list))))) (set! counter 0) (recur a-list) (display counter))

Simulaties Input : waarde van a-list ‘() ‘(1) ‘(1 2) ‘(1 2 3) … ‘(1 2 … 20) Waarde van Counter : 1 2 3 4 … 21

Groeit de rekentijd wel met n? Om dat te kunnen zien, moet de deling van het aantal recursieve oproep door n naar een constante gaan voor n groot genoeg: n = 1 ==> 2/1 = 2 n = 2 ==> 3/2 = 1.5 n = 3 ==> 4/3 = 1.3333… … n = 20 ==> 21/20 ~ 1 Als n   (het aantal recursieve oproepen / n)  1 (= constante) ==> O(n)

Voorbeeld 2

Resultaten (sim-orde 20 (lambda (x growth) (/ x (expt 1 Resultaten (sim-orde 20 (lambda (x growth) (/ x (expt 1.6181 growth)))) 1 ==> counter : 1 counter / 1.62 ^ n : 0.618008775724615 2 ==> counter : 3 counter / 1.62 ^ n : 1.14580454061791 3 ==> counter : 5 counter / 1.62 ^ n : 1.18019543561164 4 ==> counter : 9 counter / 1.62 ^ n : 1.31286804530063 5 ==> counter : 15 counter / 1.62 ^ n : 1.35227328894035 ... 18=> counter : 8361 counter / 1.62 ^ n : 1.4459783199783 [Garbage collecting... 44K of 512K] 19=> counter : 13529 counter / 1.62 ^ n : 1.44598536339877 20=> counter : 21891 counter / 1.62 ^ n : 1.44596720541673 done Als n   (het aantal recursieve oproepen / 1.6181^n)  1,4459.. (= constante) ==> O(~1.62n)

Dominantieregels O(1) < O (log2n) < O(n) < O(n log2n) < O(n2) < O(n3) < O(2n) < O(10n)

Opdracht Bereken de Orde van een scheme-Functie “length” die de lengte van een lijst bepaalt. Doe de berekening op de twee wijzen (m.a.w. vanaf het algoritme en door simulaties). Men kan een polynoom voorstellen door middel van een Vector (cf Grimaldi pg 307 Oef 5) Schrijf je eigen functie (power x n) die xn berekent. Schrijf ook een functie die de waarde van een polynoom p(x) berekent met behulp van power. Bereken de Orde van polynoom op de twee wijzen (vergeet geen rekening te houden met de Orde van power) Implementeer ook de manier beschreven in Grimaldi (pg 308 Oef 6). Die dus geen gebruik maakt van power om de waarde van een polynoom p(x) te berekenen. Bereken de Orde ervan. Welke van de twee functies is optimaal?