1 / 35

Tempo di computazione (Running Time) di programmi

Tempo di computazione (Running Time) di programmi. Misure del tempo: metodi principali Benchmarking Analisi Benchmarking : usato per confrontare programmi.

zalika
Download Presentation

Tempo di computazione (Running Time) di programmi

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Tempo di computazione (Running Time) di programmi • Misure del tempo: metodi principali • Benchmarking • Analisi • Benchmarking: usato per confrontare programmi. • Si cerca una collezione di input che sia rappresentativa dell’insieme dei possibili dati reali. Il giudizio di confronto viene espresso sugli input scelti. • Es. per algoritmi di sorting si può scegliere la collezione: • prime 20 cifre p • codici postali italiani • numeri telefonici di Roma

  2. Tempo di computazione (Running Time) di programmi ANALISI: analizza il r.t. di un dato programma Si raggruppano input per dimensione (es. ordinamento: dimensione= numero elementi da ordinare, sisteme di n equazioni in n incognite: dimensione=n) Running time: funzione T(n), con n=dimensione input, che rappresenta il numero di “unità di tempo” usate dall’algoritmo Unità di tempo varia: es. numero di istruzioni semplici in linguaggio usato (C). Tempo effettivo dipende da vari paramentri: velocità del processore usato, compilatore,….

  3. Tempo di computazione (Running Time) di programmi • Worst case (caso peggiore): su diversi input di stessa dimensione n si possono avere r.t. differenti • T(n)=worst case r.t. • = max tempo su qualsiasi input di dimentsione n • Es. cerca min A[0..n-1] (dimensione=n) • small=0; • for(j=1; j<n; j++) • if(A[j]<A[small]) • small=j; • | Linea | Numero operazioni • | 1. | 1 • | 2. | 1 + n + (n-1) =2n • | 3. | n-1 • | 4. | n-1 (worst case) • TOTALE: 1+2n+2(n-1)=4n-1 T(n)=4n-1

  4. Tempo di computazione (Running Time) di programmi Confronto di r.t.Dato un problema consideriamo 2 algoritmi A e B con r.t. T’(n) e T’’(n) T’(n)=100nT’’(n)=2n2 T’’(n) n<50, T’’(n)<T’(n) T’(n) n>50, T’’(n) > T’(n) n=100, T’’(n) = 2 T’(n) n=1000, T’’(n) = 20 T’(n) n

  5. Tempo di computazione (Running Time) di programmi T’(n)=100nT’’(n)=2n2 Unità di tempo= 1ms (millisec)  1000 operazioni/sec sec (1000ms) | max n per A | max n per B | | (100n=1000*sec) | ( 2n2=1000*sec) | 1 | 10 | 22 | 10 | 100 | 70 | 100 | 1000 | 223 | 1000 | 10000 | 707 | Se calcolatori diventano 100 volte più veloci (unità di tempo =1/100 di ms  100.000 operazioni/sec) In 10 sec A passa da n=100 ad n=10000 (*100) B passa da n=70 ad n=707 (*10)

  6. Notazione O-grande e r.t. approssimato • Dato un programma ed un input r.t. dipende ancora da • Calcolatore usato (velocità di esecuzione istruzioni) • Compilatore (numero istruzioni macchina/istruzione C) • Quindi non ha senso parlare di tempo in sec per analizzare un algoritmo. • Per nascondere effetti di 1. e 2. si usa la notazione • O-grande (big-Oh) che ignora le costanti • Es. 4m-1=O(m) (ignorando la costante moltiplicativa 4 • e quella additiva 1)

  7. Notazione O-grande e r.t. approssimato Un r.t. T(n) si assume essere definito solo per n>0 e che T(n)>0 per ogni n. Definizione Dati il r.t. T(n) ed una funzione f(n), definita per ogni intero n>0, T(n)=O(f(n))  Esistono n0>0 e c>0 tali che per ogni n>n0 risulta T(n)<cf(n) N.B. Notazione Asintotica (vale per n ‘’grande’’)

  8. Notazione O-grande e r.t. approssimato Definizione Dati il r.t. T(n) ed una funzione f(n), definita per ogni intero n>0, T(n)=O(f(n))  Esistono n0>0 e c>0 tali che per ogni n>n0 risulta T(n)<cf(n) Es. Dato T(0)=0 e T(n)=(n+1)*(n+2), n>0 mostriamo che T(n)= O(n2). (cioè f(n)=n2) Prendiamo n0=1, c=6: T(n) =(n+1)(n+2)=n2+3n+2 <n2+3n2+2n2 (per n>1, n0=1<n<n2) =6n2=c n2= c f(n)

  9. Notazione O-grande e r.t. approssimato Costanti non hanno valore T(n)=O(d T(n)), per ogni costante d Infatti: siano n0=0, c=1/d. Si ha T(n)=(1/d) d T(n)= c (d T(n))

  10. Notazione O-grande e r.t. approssimato Low-order terms non hanno valoreDato il polinomio T(n)=aknk+ak-1nk-1+…+a1n+a0, con ak>0 risulta T(n)=O(nk) Prova:

  11. Notazione O-grande e r.t. approssimato Low-order terms non hanno valoreDato il polinomio T(n)=aknk+ak-1nk-1+…+a1n+a0, con ak>0 risulta T(n)=O(nk)

  12. Notazione O-grande e r.t. approssimato Tasso di crescitaHa valore solo il termine che cresce più rapidamente. Se g(n) cresce più rap. di h(n) g(n)+h(n)=O(g(n)) Es.T(n)=2n+n3=O(2n), infatti Verificarlo in modo diretto esibendo le costanti n0 e c

  13. Notazione O-grande e r.t. approssimato Transitività Se f(n)=O(g(n)) e g(n)=O(h(n))allora f(n)=O(h(n)) f(n)=O(g(n)) Esistono c’, n’ tali che f(n) < c’ g(n) per ogni n>n’ g(n)=O(h(n)) Esistono c’’, n’’ tali che g(n) < c’’ h(n) per ogni n>n’’ Quindi, prendiamo n0=max { n’,n’’ } e c=c’c’’ Per n>n0 f(n)<c’ g(n)< c’ (c’’ h(n)) = c h(n)

  14. Notazione O-grande e r.t. approssimato Si vuole come O-grande la funzione con il minimo tasso di crescita!!! Es. f(n)=12n +3, si ha f(n)=O(n) risulta anche f(n)=O(n2), f(n)=O(n3), f(n)=O(2n),…. ma non è quello che vogliamo.

  15. Notazione O-grande e r.t. approssimato Esercizio.Mostrare che g(n)+f(n)=O(max{f(n),g(n)}) Esercizio.Mostrare che se T(n)=O(f(n)) e S(n)=O(g(n)) allora T(n)S(n)=O(f(n)g(n))

  16. Running Time di programmi • Trova f(n) tale che T(n)=O(f(n)) • Istruzioni semplici (assegnamento, confronto,…) • tempo costante O(1) • Cicli for: for (i=1,i<=n,i++) I • se I=operazione semplice risulta O(n) • Se I ha r.t. O(f(n)) risulta O(nf(n)) • es. for(i=1,i<=n,i++) A[i]=1  T(n)=O(n) • for(i=1,i<=n,i++) • for(j=1,j<=n,i++) A[i]=A[i]+A[j] •  T(n)=O(n*n) =O(n2)

  17. Running Time di programmi • If (C) I else I’: (normalmente C è O(1)) • se I,I’ sono istruzioni semplici  O(1) • se I ha r.t. O(f(n)) e I’ ha r.t. O(g(n)) •  O(max (f(n), g(n)) • es. if (A[0]=0) for(i=1,i<=n,i++) A[i]=1; • else for(i=1,i<=n,i++) • for(j=1,j<=n,i++) A[i]=A[i]+A[j] •  T(n)=O(max (n, n2)) =O(n2)

  18. Running Time di programmi Cicli while e do while: simili al ciclo for (non conosciamo esplicitamente il numero di iterazioni) es. Dato un array A di n elementi i=0; while (x<>A[i] && i<n) i=i+1; (caso peggiore: n iterazioni)  T(n)=nO(1)=O(n)

  19. Running Time di programmi Sequenze di istruzioni:si devono sommare i tempi delle singole istruzioni. Si usa la regola della somma. Date con O(f1) O(f2) . . . O(fm) {I1; I2; . . . Im;} Risulta O(f1(n))+ O(f2(n))+…+ O(fm(n))= O(fi(n)) fj(n)=O(fi(n)) per ogni j diverso da i.

  20. Running Time di programmi • Chiamate a funzioni:si deve sommare il tempo • della funzione chiamata. • (se A chiama B: si calcola il r.t. di B e si somma al • r.t. delle altre istruzioni di A) • Chiamate ricorsive: determiniamo T(n) in modo induttivo • Tempo di una chiamata che non usa ricorsione = t (=O(1)) • Si esprime T(n) in termini del tempo T(n’) della chiamata ricorsiva

  21. Running Time di programmi • Chiamate ricorsive: determiniamo T(n) in modo induttivo • Tempo di una chiamata che non usa ricorsione=t (=O(1)) • Si esprime T(n) in termini del tempo T(n’) della chiamata ricorsiva Es. int fact(int n) { if (n<=1) return 1; else return n*fact(n-1)} T(1)=t T(n)=T(n-1)+c

  22. Running Time di programmi Es. int fact(int n) { if (n<=1) return 1; else return n*fact(n-1)} T(1)=t T(n)=c+ T(n-1) Vogliamo il valore di T(n) (non dipendente da T(n’)) Abbiamo T(n)=c+ T(n-1) =c+ c+ T(n-2)= 2c +T(n-2)

  23. Running Time di programmi Es. int fact(int n) { if (n<=1) return 1; else return n*fact(n-1)} T(1)=t T(n)=c+ T(n-1) Abbiamo T(n)=c+T(n-1) =c+ c+ T(n-2)= 2c +T(n-2) =2c +c +T(n-3)=3c +T(n-3)

  24. Running Time di programmi Es. int fact(int n) { if (n<=1) return 1; else return n*fact(n-1)} T(1)=t T(n)=c+ T(n-1) Abbiamo T(n)=c+T(n-1) =c+ c+ T(n-2)= 2c +T(n-2) =2c +c +T(n-3)=3c +T(n-3) … =ic +T(n-i) (per i=n-1) =(n-1)c+T(1) =(n-1)c+t=O(n)

  25. Running Time di programmi Esercizio. Dimostrare per induzione su n che la relazione di ricorrenza T(1)=t T(n)=c+ T(n-1) ha come soluzione T(n)=(n-1)c + t Base n=1. T(1)=t=(1-1)c+t. OK. Passo. Sia n> 1. Assumiamo T(n)=(n-1)c + t. Consideriamo T(n+1) T(n+1)=c + T(n) (per definizione) =c + (n-1)c + t (per i.i.) = nc +t

  26. Running Time di programmi • Esercizio. Considerare la relazione di ricorrenza • T(0)=T(1)= 1 • T(n)=2 T(n-2) • Determinare T(2), T(3), T(4), T(5): • T(2)=2, T(3)=2, T(4)=4, T(5)=4 • Determinare T(n) in termini di T(n-4): T(n)=4 T(n-4) • Determinare T(n) in termini di T(n-6): T(n)=8 T(n-6) • Determinare T(n) in termini di T(n-2i): T(n)=2i T(n-2i) • Determinare T(n): • sen pari, i=n/2, T(n-2i)=T(0) T(n)=2n/2T(0)=2n/2 • sen disp., i=(n-1)/2, T(n-2i)=T(1) T(n)=2(n-1)/2T(1) =2(n-1)/2

  27. Soluzioni Relazioni di ricorrenza • T(1)=a • T(n)= b+T(n-1), n>1  T(n)=(n-1)b+a • 2. T(k)=a • T(n)=T(n-1)+g(n)  T(n)=a + g(k+1)+…+g(n) • T(n) = g(n)+T(n-1) • = g(n)+g(n-1)+T(n-2)=… • … • = g(n)+g(n-1)+…+g(k+1)+T(k) • T(1)=1 • T(n)=T(n-1)+n  (g(i)=i) T(n)=1 + 2+…+n=n(n+1)/2

  28. Soluzioni Relazioni di ricorrenza 4. T(1)=a T(n)=2T(n/2)+g(n) 

  29. Soluzioni Relazioni di ricorrenza 4. T(1)=a T(n)=2T(n/2)+g 

  30. Soluzioni Relazioni di ricorrenza 4. T(1)=a T(n)=2T(n/2)+n 

More Related