3.2 Kompleksisuus Vain pieni osa kaikista tehtävistä on laskettavissa tai edes osittainkaan laskettavissa. Laskettavien osalta saattaa olla tarpeellista etukäteen tietää, minkä verran ne kuluttavat tietokoneen resursseja. Kompleksisuusteoria = tietojenkäsittelytieteen haara, joka tutkii kuinka paljon algoritmien suorittamisessa tarvitaan resursseja. Kompleksisuuden avulla voidaan vertailla eri algoritmien tehokkuutta saman tehtävän suorittamisessa.

Esimerkiksi syt-moduuli (s.48): MODULE syt (x, y) RETURNS x:n ja y:n suurin y. t. IF (x = y) THEN RETURN x ENDIF IF (x > y) THEN RETURN syt(x-y,y) ENDIF IF (x < y) THEN RETURN syt(x, y-x) ENDIF ENDMODULE Esim. syt(24,15) = syt(9, 15) = syt(9, 6) = syt(3, 6) = syt(3,3) = 3 Vastaava iteraatioon perustuva moduuli on sivulla 32.

Esimerkiksi syt-moduuli (s.48): Voidaan osoittaa, että syt(x, y) = syt(y, x MOD y) missä x MOD y tarkoittaa osamäärän x/y jakojäännöstä. Siten esimerkiksi syt(75,6) = syt (6,3)= syt (3, 0) = 3 (kun lisäksi määritellään, että syt(x,0) = x. Peräkkäiset vähennyslaskut on korvattu yhdellä jakolaskulla.

Nopeampi syt-moduuli : MODULE syt (x, y) RETURNS x:n ja y:n suurin y. t. IF (y = 0) THEN RETURN x ENDIF ELSE RETURN syt(y, x MOD y) ENDIF ENDMODULE Tämä algoritmi on sitä nopeampi mitä suurempi on lukujen x ja y erotus. Vrt. syt(24,15) =syt(15,9)=syt(9, 6)=syt(6,3)=syt(3,0)=3 ja toisaalta syt(240,15)= syt(15, 0)=15.

kompleksisuus... Vaikka tehtävä olisi laskettavissa, niin tehtävään laaditun algoritmin suorittaminen voi viedä liikaa resursseja. Tehtävä on kelvollinen (feasible), jos sen ratkaisemiseen on löydettävissä käyttökelpoinen algoritmi ja jos resurssitarve on kohtuullinen.

kompleksisuus...

kompleksisuus... Tärkeimmät tietokoneresurssit aika muisti (tila) laitteisto

kompleksisuus... tehtävän vaikeus kasvaa syötteen koon kasvaessa. Algoritmit käsittelevät syötettä, jonka koko (määrä) vaikuttaa algoritmin resurssi- tarpeeseen, yleensä niin, että tehtävän vaikeus kasvaa syötteen koon kasvaessa.

kompleksisuus... Algoritmin kompleksisuudella tarkoitetaan suoritukseen vaadittavien resurssien määrän riippuvuutta tehtävän koosta huonoimmassa tapauksessa. Tehtävän kompleksisuudella tarkoitetaan parhaan algoritmin (joka ratkaisee tehtävän) kompleksisuutta.

kompleksisuus... On pyrittävä löytämään kulloiseenkin tilanteeseen sopiva tasapaino eri resurssien välillä. Kriittiseksi muodostuva resurssi riippuu sovelluksesta: esim. tietokantajärjestelmissä se on tila, ohjausjärjestelmissä (lentokone, juna, auto, risteilyohjus) aika.

kompleksisuus... Seuraavaksi tarkastellaan aikaa. Algoritmin aikakompleksisuus eli aikavaativuus ilmoitetaan syötteen koon (n) funktiona T(n). Ajan yksikkönä ei käytetä todellista aikaa, vaan laitteistosta riippumatonta keskeistä alkeisoperaatioiden (esim. laskutoimitus) lukumäärää (kutsutaan niitä askeleiksi). yhteen- ja vähennyslasku kerto- ja jakolasku vertailut rekursiokutsut (ei huomioida luentomonisteessa)

MODULE VektorinSumma(v,n) RETURNS v:n alkioiden summa FOR i:=1..n DO summa:=summa + v[i] ENDFOR RETURN summa ENDMODULE Mikä on tämän moduulin aikavaativuus? silmukkalaskurin päivitystä ei yleensä oteta huomioon, koska se on erittäin vähän aikaa vievä operaatio samoin asetuslause kahden muuttujan yhteenlasku on sen sijaan hitaampi operaatio ja siksi on tarkastelun kohteena yhteenlaskuja tehdään 1 per kierros on kaiken kaikkiaan n kierrosta eli n yhteenlaskua (askelta) vastaus: moduulin VektorinSumma(v,n) aikavaativuus on T(n)=n Jos vektorin koko on 7, tehdään 7 askelta. Jos koko on 14, tehdään 14 askelta. Riippuvuus tehtävän koon ja suoritukseen kuluvan ajan välillä on lineraarinen, ja on T(n) = n

Polynomin arvo pisteessä x (s. 83) esim P(x) = 2x3 -4x2 +5x + 3 x annettu, halutaan tietää P(x) arvo P(x) yleisessä muodossa on P(x) =anxn+an-1xn-1+...+a1x1 + a0x0 = anxn+an-1xn-1+...+a1x + a0 polynomin erottavat sisaruksistaan omat kertoimet, esim. sivun ylälaidan polynomissa 2, 4, 5, 3, niitä on yleensä n+1 kpl, kun polynomin potenssi (korkein eksponentti) on n laaditaan moduuli, jossa aixi termien yheenlaskua i käy läpi arvot 1..n ensin lasketaan x potenssiin i, sitten termi aixi tervi aixi lisätään summa-muuttujaan

MODULE P(a0,..., an, x) RETURNS Pn(x) summa := a0 (* summan alustus *) FOR i:=1,...,n DO (* lasketaan x:n i.s potenssi: *) xpot:= 1 REPEAT i TIMES xpot := xpot * x ENDREPEAT (* termin arvo summataan summaan *) summa := summa + ai * xpot ENDFOR RETURN summa ENDMODULE

Aikavaativuusanalyysiä.. mitä enemmän termejä polynomissa (mitä suurempi on n), sitä enemmän toistoja tehdään jokaisella kieroksella i+1 kertolaskua ja yksi yhteenlasku kertolaskuja yhteensä T1(n)=2+3+…+(n+1) = = 1+2+..n – 1 + (n+1) =n(n+1)/2 – 1 + n + 1 = = n(n+1)/2 + n = (n(n+1)+2n)/2 = n(n+3)/2 yhteenlaskuja yhteensä T2(n)=n tehoton algoritmi => jos termejä on n, pitää tehdä neliöllisesti kertolaskuja! tehostetaan potenssilaskua hieman

potenssia ei ole tarpeen laskea joka kierroksella alusta asti MODULE P(a0,..., an, x) RETURNS Pn(x) summa := a0 xpot := 1 FORi:=1,...,n DO xpot := xpot *x summa := summa + ai * xpot ENDFOR RETURN summa ENDMODULE potenssia ei ole tarpeen laskea joka kierroksella alusta asti se saadaan laskettua kertomalla edellisen kierroksen potenssi x:llä kertolaskuja T1(n)=2n, yhteenlaskuja T2(n)=n jo parempi tehokkuus, muttei täydellinen tehostetaan hieman lisää

P3(x) = 2x3 -4x2 +5x + 3 voidaan kirjoittaa muodossa P3(x) = ((2x - 4)x + 5)x + 3 eli yleistäen Pn(x) = (((anx + an-1)x + an-2)x +...+a1)x + a0 Määritellään tämän uuden muodon termit Vi:llä sisimmistä lähtien ulompaanpäin: Vn = an Vk = x*Vk+1 + ak, kun k = n-1,n-2,…0 nyt Pn(x) = V0 (kaikkein uloin termi) huom. rekursio etenee 0:sta n:ään, eikä n:stä nollaan, niin kuin ollaan totuttu rekursion kanta löytyy Vn:stä

Pn(x) = V0 (kaikkein uloin termi): MODULE V(k,a0,...,an,x) RETURNS Vk(x) IF k=n THEN (* rekursion kanta *) RETURN an ELSE (* rekursion askel *) RETURN x*V(k+1,a0,...,an,x)+ak ENDIF ENDMODULE Pn(x) = V0 (kaikkein uloin termi): MODULE P(a0,...,an,x) RETURNS Pk(x) RETURN V(0,a0,...,an,x)

Aikavaativuusanalyysiä 2.. mikä on viimeksi laaditun moduulin P aikavaativuus? = moduulin V aikavaativuus siinä on 1 kertolasku ja 1 yhteenlasku k+1 ei huomioida, vastaa silmukalaskurin kasvattamista rekursiota ei luentomonisteessa huomioida, vaikka pitäisi rekursiotasoja on 0..n=n+1, mutta n:llä tasolla ei tehdä mitään, niin T1(n) = n ja T2(n) = n ekan algoritmin T1(n) oli n(n+3)/2 parannusta (n+3)/2 verran!!! koska yhteenlaskut ovat kertolaskuja paljon nopeampia suorittaa, niitä ei huomoida, eli T2:t jätetään pois tarkastelusta nyt askeleiden määrä kasvaa samassa määrin kuin tehtävän koko, riippuvuus on lineraarinen, T(n) = n katso myös iteratiivinen toteutus kotona