3.2 Kompleksisuus
Vain pieni osa kaikista tehtävistä on laskettavissa taiedes osittainkaan laskettavissa.
Laskettavien osalta saattaa olla tarpeellista etukäteentietää, minkä verran ne kuluttavat tietokoneenresursseja.
Kompleksisuusteoria = tietojenkäsittelytieteen haara,joka tutkii kuinka paljon algoritmien suorittamisessatarvitaan resursseja.
Kompleksisuuden avulla voidaan vertailla eri algoritmientehokkuutta 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...
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
summa:=0
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 operaatioja 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 14askelta. Riippuvuus tehtävän koon ja suoritukseen kuluvan ajanvä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 onP(x) =anxn+an-1xn-1+...+a1x1 + a0x0 =anxn+an-1xn-1+...+a1x + a0
polynomin erottavat sisaruksistaan omat kertoimet,esim. sivun ylälaidan polynomissa2, 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 yksiyhteenlasku
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
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 alustaasti
se saadaan laskettua kertomalla edellisen kierroksenpotenssi 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 kirjoittaamuodossa P3(x) = ((2x - 4)x + 5)x + 3
eli yleistäenPn(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ä
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)
ENDMODULE
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