Algoritmi e Calcolo Parallelo 2012/2013 - Analisi degli Algoritmi

Prof. Pier Luca Lanzi

Analisi degli AlgoritmiAlgoritmi e Calcolo Parallelo


Riferimenti

• Bertossi Alan A., Montresor Alberto. “Algoritmi e strutture di dati” (seconda edizione), CittàStudi 2010

• Stanley B. Lippman, Barbara E. Moo, Josee Lajoie“C++ Primer”, 5th Edition Addison-Wesley

2


“ As soon as an Analytic Engine exists, it will necessarily guide the future course of the science. Whenever any result is sought by its aid, the question will arise—By what course of calculation can these results be arrived at by the machine in the shortest time?” - Charles Babbage (1864)


Esempio: Ordinamento di un Vettore

• Definizione del Problema

Input: sequenza áa1, a2, …, anñ di numeri.

Output: permutazione áa'1, a'2, …, a'nñ che soddisfi

la relazione a'1 £ a'2 £ … £ a'n

• Esempio Input: 8 2 4 9 3 6Output: 2 3 4 6 8 9

4


Algoritmo di Insertion Sort(pseudo codice)

insertionSort(array A) for i ← 1 to length[A]-1 do value ← A[i] j ← i-1 while j >= 0 and A[j] > value do A[j + 1] ← A[j] j ← j-1 A[j+1] ← value

http://ideone.com/3Sn5m

5

sorted

i j

key

A:0 n-1


Insertion Sort: Animazione da Wikipedia

Animazione dell’Insertion Sort da Wikipediahttp://en.wikipedia.org/wiki/Insertion_sorthttp://en.wikipedia.org/wiki/Image:Insertion_sort_animation.gif

6


Esempio di Insertion Sort

8 2 4 9 3 6

7

Prof. Pier Luca LanziL1.8


8 2 4 9 3 6

8



8 2 4 9 3 6

2 8 4 9 3 6

9



8 2 4 9 3 6

2 8 4 9 3 6

10



8 2 4 9 3 6

2 8 4 9 3 6

2 4 8 9 3 6

11



8 2 4 9 3 6

2 8 4 9 3 6

2 4 8 9 3 6

12



8 2 4 9 3 6

2 8 4 9 3 6

2 4 8 9 3 6

2 4 8 9 3 6

13



8 2 4 9 3 6

2 8 4 9 3 6

2 4 8 9 3 6

2 4 8 9 3 6

14



8 2 4 9 3 6

2 8 4 9 3 6

2 4 8 9 3 6

2 4 8 9 3 6

2 3 4 8 9 6

15



8 2 4 9 3 6

2 8 4 9 3 6

2 4 8 9 3 6

2 4 8 9 3 6

2 3 4 8 9 6

16



8 2 4 9 3 6

2 8 4 9 3 6

2 4 8 9 3 6

2 4 8 9 3 6

2 3 4 8 9 6

2 3 4 6 8 9 Fatto!

17


Tempo di Esecuzione

• Dipende dall’inputDal numero di elementi Dallo stato del vettore, una sequenza già

ordinatarichiede meno tempo

• Calcolare il tempo di esecuzione parametrizzandolo rispetto al numero di elementi di input (vettori più piccoli richiedono meno tempo)

• Cerchiamo limiti superiori al tempo di esecuzione dato che danno una garanzia sul tempo massimo richiesto

18


Quale Definizione di Tempo?

• Tempo = “Wall-clock” time: Il tempo effettivamente impiegato per eseguire

un algoritmo

• Dipende da troppi parametri:bravura del programmatore linguaggio di programmazione utilizzatocodice generato dal compilatoreprocessore, memoria (cache, primaria,

secondaria)sistema operativo, processi attualmente in

esecuzione

• Dobbiamo considerare un modello astratto, che possiamo derivare empiricamente o analiticamente

19


Analisi Empirica


Analisi Empirica delTempo di Esecuzione

• Instrumentare il codice con le istruzioni per la rilevazione del tempo trascorso

• Eseguire il codice con dati di input di diverse dimensioni(eventualmente piu’ volte per la stessa dimensione)

• Analisi dei dati raccolti

21


Instrumentare il Codice:Insertion Sort

clock_t begin=clock();for(int i=1; i<=n-1; i++){ int value = A[i]; int j = i-1; while ( (j>=0) && (A[j]>value) ) { A[j+1] = A[j]; j = j-1; } A[j+1] = value;}

clock_t end=clock();

// stampa i millisecondistd::cout << double(end-begin)*1000/CLOCKS_PER_SEC << std::endl;// http://ideone.com/UuX1d

22


Raccolta Dati & Analisi

N T(N)

10002000400080001600

03200

06400

0

5.76915.31663.204

244.228988.693908.815949

23


Analisi Dati

• Considerare il grafico utilizzando le scale logaritmiche sia per l’ascissa che l’ordinata

• Interpolare i punti ottenutiassumendo una relazionelineare

log2(T(N)) = blog2(N)+c

• Ottenendo

T(N) = aNb dove a=2c

24


Metodo per Ottenere una Stima di b

• Eseguire il programma raddoppiando la grandezza dell’input

• Ipotizzando che il tempo di esecuzione abbia sia aNb allora, b e’ puo’ essere calcolato come il log2 del ratio

• In questo caso possiamo assumere che b sia 2

25

N T(N) Ratio Log(Ratio)1000 5.772000 15.32 2.65 1.414000 63.20 4.13 2.048000 244.23 3.86 1.95

16000 988.69 4.05 2.02

320003908.8

0 3.95 1.98

6400015949.

00 4.08 2.03

converge a ~2


Metodo per Ottenere una Stima di a

• Assumendo di conoscere b, si puo’ ricavare a, misurando il tempo di esecuzione per un N abbastanza grande

• Ad esempio, con b=2,

974.36 = aN2

• Si ricava, otteniamo a = .38x10-5

26

N T(N)

16000

16000

16000

988.7967.1967.3


Modello Analitico


Quale Definizione di Tempo?

• Tempo = “numero operazioni elementari”

• Quali operazioni possono essere considerate elementari?Moltiplicazioni, assegnamenti elementari, ecc.Possiamo considerare il calcolo del minimo di un

vettore di n elementi un’operazione elementare?

• Modello di calcoloRappresentazione astratta di un esecutore (il

calcolatore)L’astrazione elimina i dettagli inutili Il modello computazionale deve riflettere la

situazione realeDeve permettere di trarre conclusioni “formali”

sul costo

28


Esempio: Elemento Minimo di un Vettore

• Ogni istruzione richiede un tempo costante per essere eseguita

• Costante diversa da istruzione a istruzione

• Ogni istruzione viene eseguita un certo # di volte, dipendente da n

• T(n) = c1+ n*c2 + (n-1)*c3 + (n-1)*c1 + c4 = a*n+b

29

int minimo(std::vector<int> A) // costo # esecuzioni{ int m = A[0]; // c1 1 int i;

for(i=1; i<A.size(); i++) // c2 n if (m>A[i]) // c3 n-1 m = A[i]; // c1 n-1

return m; // c4 1}


Esempio: Ricerca Binaria Ricorsiva

• T(n) = c1 + c2 + c1 + c3 + T(n/2) = T(n/2) + d se n>1

• T(n) = c1 altrimenti

30

bool recursive_binary_find(std::vector<int> A, int lower, int upper, int x){ // costo # esecuzioni

if (upper<lower) return false; c1 1

int m = (lower+upper)/2; c2 1

if (x==A[m]) return true; c1 1

if (x>A[m]) c3 1 return recursive_binary_find(A, m+1, upper, x); T(n/2) 1 else return recursive_binary_find(A,lower, m-1, x); T(n/2) 1

} // http://ideone.com/AH7Dg


Calcolo T(n) per la Ricerca Binaria Ricorsiva

• AssunzioniPer semplicità, n =2k è una potenza di 2L’elemento cercato non è presente (caso

pessimo)Ad ogni suddivisione, scegliamo sempre la parte

destra di dimensione n/2 (caso pessimo)

• Equazione alle ricorrenze

31


Calcolo T(n) per la Ricerca Binaria Ricorsiva

32


Quale Tipo di Analisi?

• Caso Pessimo (worst-case): (tipico)T(n) tempo massimo per un input di n elementi

• Caso Medio (average-case): (raramente disponibile)T(n) tempo medio per un input di n elementiProblema: Qual è la distribuzione degli input?

• Caso Migliore (best-case): (non informativo)Algoritmi lenti possono essere molto veloci in

casi particolarmente favorevoli

Non considerare una particolare macchina

Analisi Asintotica - Studiare T(n) per n → ∞

33


Andamento Asintotico per T(n) 34


Nuovo PC 10 volte più velocein T esegue 105 istruzioni

Vecchio PC in un tempo T esegue 104 istruzioni

Quanto guadagno se comperoun calcolatore 10 volte più veloce?


T

104# istruzioni 105

algoritmo 10n nV=104/10=1000 nN=10000

In termini di capacità di calcolo il guadagno è nN/nV = 10

Con un algoritmo di complessità linearel’aumento di potenza di calcolo si è trasferito

nell’effettiva capacità di elaborazione


T

104# istruzioni 105

algoritmo 10n nV=103 nN=104 nN/nV =10


algoritmo 5nlogn nV=250 nN=1843 nN/nV =7.3

Con un algoritmo 5nlogn l’aumento di velocità si è soloparzialmente trasferito in capacità di elaborazione

Il calcolatore è 10 volte più veloce ma elabora solo un numero di dati che è solo 7.3 volte più grande


T

104# istruzioni 105



algoritmo 5nlog n nV=250 nN=1843 nN/nV =7.3

algoritmo 2n2 nV=70 nN=223 nN/nV =3.2

algoritmo 2n nV=13 nN=16 nN/nV =1.2

Aumentando la complessità dell’algoritmo, il vantaggio diventa irrisorio come nel caso 2n


Per a, b > 1 qualsiasi

na cresce più velocemente di logb n(meglio logaritmico che polinomiale)

na cresce più velocemente di log nb

(meglio potenza di un logaritmo che un polinomio)

an cresce più velocemente nb

(meglio polinomiale che esponenziale)


Analisi Asintotica: Notazione O-grande

• Definizione: sia T(n) una funzione non-negativa, T(n) è O(f(n)) se esistono due costanti positive c ed n0 tali che T(n) <= cf(n) per ogni n> n0

• Per tutti i gli insiemi di dati di input grandi a sufficienza, (n>n0), l’algoritmo termina la sua esecuzione in meno di cf(n) passi (nel caso migliore, medio, o peggiore).

• La notazione O-grande indica un limite superiore a T(n)

• Esempio: se T(n) = 3n2 allora T(n) è in O(n2)

• Ovviamente siamo interessati al minimo limite superiore, se T(n) = 3n2 è O(n3), ma preferiamo O(n2)

40


Analisi Asintotica: Notazione Ω-grande

• Definizione: sia T(n) una funzione non-negativa, T(n) è Ω(g(n)) se esistono due costanti positive c ed n0 tali che T(n) >= cg(n) per ogni n> n0

• Per tutti i gli insiemi di dati di input grandi a sufficienza, (n>n0), l’algoritmo ha bisogno almeno di cg(n) passi (nel caso migliore, medio, o peggiore).

• La notazione Ω-grande indica un limite inferiore a T(n)

• Esempio: se T(n) = 2n2+n allora T(n) è in Ω(n2)

• Ovviamente siamo interessati al massimo limite inferiore, T(n) = 2n2+n è Ω(n), ma preferiamo Ω(n2)

41


Analisi Asintotica: Notazione Θ-grande

• Definizione: se T(n) è Ω(h(n)) e anche O(h(n)) allora T(n) è Θ(h(n))

• Ovvero, se esistono due costanti c1 e c2, ed n0 tali che c1g(n) ≤ f(n) ≤ c2g(n) per ogni n>n0

42


Analisi Asintotica 43

• Vero asintoticamente!

• Non ignorare gli algoritmi che sono asintoticamente lenti

• Nelle situazioni reali bisogna spesso bilanciare obiettivi contrapposti

• Tipico esempio, performance vs. complessità

n

T(n)

n0

Per n grande, un algoritmo Θ(n2) è sempre più veloce di un algoritmo Θ (n3)


Andamento Asintotico per T(n) 44


Andamento Asintotico (log-log) 45


Regole di Semplificazione

• Se f(n) è O(g(n)) e g(n) è O(h(n)), allora f(n) è O(h(n))

• Se f(n) è O(kg(n)) per ogni k>0, allora f(n) è O(g(n))

• Se f1(n) è O(g1(n)) ed f2(n) è O(g2(n)), allora (f1 + f2)(n) è O(max(g1(n), g2(n)))

• Se f1(n) è O(g1(n)) ed f2(n) è O(g2(n)),allora f1(n)f2(n) è O(g1(n)g2(n))

• In breve, eliminare i termini di ordine inferiore, ignorare le costanti.

46


Limitazioni Inferiori e Algoritmi Ottimi

• Dato un problema, se troviamo un algoritmo A con complessità O(g(n)), avete stabilito un limite superiore alla complessità del problema - g(n)

• Se dimostrate che qualunque algoritmo per il problema deve avere complessità Ω(f(n)), avete stabilito un limite inferiore all complessità del problema - f(n)

• Se f(n)=g(n), allora A è un algoritmo ottimo

47


Esempi di Analisi Asintotica

• Esempio 1:

a = b;

• Esempio 2:

sum = 0;for (i=1; i<=n; i++) sum += n;



• Esempio 3:

sum = 0;for (i=1; i<=n; i++) for (j=1; j<=i; j++) sum++;for (k=0; k<n; k++) A[k] = k;

49



• Esempio 4:

sum1 = 0;for (i=1; i<=n; i++) for (j=1; j<=n; j++) sum1++;

sum2 = 0;for (i=1; i<=n; i++) for (j=1; j<=i; j++) sum2++;

50



• Esempio 5:

sum1 = 0;for (k=1; k<=n; k*=2) for (j=1; j<=n; j++) sum1++;

sum2 = 0;for (k=1; k<=n; k*=2) for (j=1; j<=k; j++) sum2++;

51


Strutture di Controllo

• Istruzione while: viene analizzato come il ciclo for

• Istruzione if: complessità del blocco più costoso

• Istruzione switch: complessità del caso più costoso

• Chiamata a subroutine: complessità della subroutine

• Passaggio dei parametri: Tipi semplici, il costo è una costante Vettori o strutture, se passati per indirizzo,

il passaggio ha un costo costante Altrimenti, il costo è quello della copia

52


Qual è la Complessità Insertion Sort?

insertionSort(array A) for i ← 1 to length[A]-1 do value ← A[i] j ← i-1 while j >= 0 and A[j] > value do A[j + 1] ← A[j] j ← j-1 A[j+1] ← value

53


Qual è la Complessità Insertion Sort?

void insertion_sort(std::vector<int> &A){ int i; int j; int value; for(i=1; i<A.size(); i++) { value = A[i]; j = i-1; while(j>=0 && A[j]>value) { A[j+1] = A[j]; j = j-1; } A[j+1] = value; }} // http://ideone.com/siE9V

54


55Analisi Asintotica dell’Insertion Sort

• Caso Peggiore:

• Caso Medio: (tutte le possibili permutazioni siano equiprobabili)

• È un algoritmo veloce? Si, per n piccoli No, per n grandi

n

j

n)/j()n(T2

22

n

j

n)j()n(T2

2


Cosa Succede Se Abbiamo Più Parametri?

• Calcoliamo la frequenza di tutti i C colori in un’immagine di P pixel

for (i=0; i<C; i++) // Initialize count count[i] = 0;for (i=0; i<P; i++) // Look at all pixels count[value(i)]++; // Increment countsort(count); // Sort pixel counts

• Se usiamo C come parametri, allora T(n) = (C log C)

• Se usiamo P come parametri, allora T(n) = (P)

• È più accurato T(n) = (P + C log C)

56


57Algoritmo di Ordinamento Merge Sort

• Principio di base dell’algoritmo Dato un vettore, suddividerlo in due sottovettori di uguale

lunghezza Applicare il merge sort ai due sottovettori Fondere i due sottovettori “sfruttando” il fatto che sono

ordinati

• Pseudo codice

mergesort(array A) if (|A|=1) return; A1 ← mergesort(A[1..n/2]); A2 ← mergesort(A[n/2+1 .. n]); A ← merge(A1,A2);


Merge Sort in C++http://www.ideone.com/9CZJu

// &A indica che il vettore A verra' modificatovoid merge_sort(std::vector<int> &A){

std::vector<int> A1;std::vector<int> A2;

if (A.size()==1) return;

for(int i=0; i<A.size()/2; i++)A1.push_back(A[i]);

for(int i=A.size()/2; i<A.size(); i++)A2.push_back(A[i]);

merge_sort(A1);merge_sort(A2);A = merge(A1,A2);

}

58


Algoritmo di Ordinamento Merge Sort

59


Merge Sort: Animazione da Wikipedia

Animazione del Merge Sort da Wikipediahttp://en.wikipedia.org/wiki/Merge_sorthttp://upload.wikimedia.org/wikipedia/en/c/c5/Merge_sort_animation2.gif

60

http://en.wikipedia.org/wiki/Merge_sort


12

Merge di Due Vettori Ordinati

20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9

20

13

12

11

11

20

13

12

Il merge è Θ(n)

61


Insertion Sort vs Merge Sort

• InsertionSortHa un approccio incrementaleA[1..j-1] ordinato, aggiungi A[j]

• MergeSortHa un approccio divide-et-imperaTre passi: Divide, Impera, Combina

• Divide: Divide il vettore di n elementi in due array di n/2 elementi

• Impera: Chiama il MergeSort ricorsivamente su i due array

• Combina: Fa il merge delle due sequenze ordinate

62


Analisi Asintotica del Merge Sort

T(1) = Θ(1)

T(n) = 2T(n/2) + Θ(n)

T(n) mergesort(array A)c if (|A|=1) return;2T(n/2) A1 ← mergesort(A[1..n/2]); A2 ← mergesort(A[n/2+1 .. n]);Θ(n) A ← merge(A1,A2);

63



Calcolare T(n) = 2T(n/2) + cn, dove c > 0 è una constante

64

Prof. Pier Luca LanziL1.65



T(n)

65




T(n/2) T(n/2)

cn

66




cn

T(n/4) T(n/4) T(n/4) T(n/4)

cn/2 cn/2

67



Calcolare T(n) = 2T(n/2) + cn, dove c > 0 è una costante

cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Θ(1)

…

68




cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Θ(1)

…

h = log n

69




cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Θ(1)

…

h = log n

cn

70




cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Θ(1)

…

h = log n

cn

cn

71




cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Θ(1)

…

h = log n

cn

cn

cn

…

72


n elementin elementi



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Θ(1)

…

h = log n

cn

cn

cn

Q(n)

…

73


n elementin elementi



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Θ(1)

…

h = log n

cn

cn

cn

Q(n)

Total = Q(n log n)

…

74


Θ(nlogn) cresce più lentamente di Θ(n2)

Asintoticamente il merge sort è meglio dell’insertion sort

In pratica il merge sort è conveniente per n>30


Possiamo Parallelizzare il Merge Sort?

mergesort(array A) if (|A|=1) return; A1 ← mergesort(A[1..n/2]); A2 ← mergesort(A[n/2+1 .. n]); A ← merge(A1,A2);

76


Scalabilità nel Calcolo Parallelo?

Prof. Lanzi deve ordinare N compiti

77

(Sequenziale)Quanto ci mette

da solo?

(Caso Parallelo)Quanto se ci

sono 2 volontari?

(Caso Parallelo)Quanto se ci sono

p volontari?


Counting Sort

• I numeri da ordinare sono compresi in un range [1..k]

• Costruire un array B[1..k] che conta il numero di volte che compare un valore in [1..k]

78


Counting Sort in C++http://www.ideone.com/muOp5

void counting_sort(std::vector<int> &A, unsigned int k){

// B e' un vettore di dimensione k inizializzato a 0std::vector<int> B(k,0);

for(int i=0; i<A.size(); i++)B[A[i]]++;

int j = 0;

for(int i=0; i<k; i++){

while (B[i]>0){

A[j] = i;j++;B[i]--;

}}

}

79


Complessità del Counting Sort

• La complessità del counting sort è O(n+k)

• Se k è O(n), allora la complessità è O(n) quindi è il migliore algoritmo visto finora

• Però il Counting Sort non è basato su confronti e quindi si applica solo a vettori di numeri interi

• Abbiamo cambiato le condizioni di base

• Inoltre, se k è O(n3), questo algoritmo è il peggiore rispetto a tutti quelli visti finora

80


Qual è la Complessità dell’Ordinamento?

• Abbiamo visto algoritmi di sort comparativi e il counting sort

• Per ordinare un insieme di elementi usa solo la comparazione fra due elementi (insertion sort, merge sort, quick sort)

• La complessità migliore per il worst-case che abbiamo visto finora è Θ(n lg n)

È Θ(n lg n) il meglio che possiamo fare?

Per rispondere usiamo gli alberi di decisione

81


Quanti Confronti?

• Supponiamo di dover ordinare un vettore di tre elementi, a1, a2, e a3, quanti/quali confronti dobbiamo effetuare?

• Utilizziamo gli alberi di decisione, con questa notazione i:j indica il confronto fra ai e aj il sottoalbero sinistro rappresenta i confronti successivi se

ai ≤ aj quello destro i confronti se ai > aj

Ogni foglia contiene un possibile risultato

1:21:2

2:32:3

123123 1:31:3

132132 312312

1:31:3

213213 2:32:3

231231 321321

82


Esempio

• Come esempio, proviamo ad ordinare il vettore <9,4,6>

1:21:2

2:32:3

123123 1:31:3

132132 312312

1:31:3

213213 2:32:3

231231 321321

a1 ≤ a2?

9 ³ 4

83


Esempio: Ordinamento di <9,4,6>

1:21:2

2:32:3

123123 1:31:3

132132 312312

1:31:3

213213 2:32:3

231231 321321

a1 ≤ a3?

9 ³ 6

84


Esempio: Ordinamento di <9,4,6>

1:21:2

2:32:3

123123 1:31:3

132132 312312

1:31:3

213213 2:32:3

231231 321321

a2 ≤ a3?

4 ≤ 6

85


Alberi di Decisione come Modello dell’Ordinamento

• Ogni algoritmo basato su confronto può essere sempre descritto tramite un albero di decisione

• Cammino radice-foglia in un albero di decisione:sequenza di confronti eseguiti dall'algoritmo corrispondente

• Altezza dell'albero di decisione:# confronti eseguiti dall'algoritmo corrispondente nel caso pessimo

• Altezza media dell'albero di decisione:# confronti eseguiti dall'algoritmo corrispondente nel caso medio

Un albero di decisione modella l’esecuzione di unqualsiasi algoritmo di ordinamento per confronto

86


Limitazione Inferiore alla Complessità dell’Ordinamento per Confronto• Lemma: Un albero di decisione per l'ordinamento di n

elementi contiene almeno n! Foglie

• Lemma: Sia T un albero binario in cui ogni nodo interno ha esattamente 2 figli e sia k il numero delle sue foglie. L'altezza dell'albero è almeno log k

• Teorema: Un albero di decisione per l’ordinamento di n elemento ha altezza Ω(n lg n).

Dimostrazione: l’albero deve contenere almeno n! foglie quindi dato che un albero di altezza h contiene al massimo 2h foglie si ha che n!≤2h e quindi:

h ≥ lg(n!) ≥ lg ((n/e)n) (approssimazione Stirling)= n lg n – n lg e= Ω(n lg n)

87


Limitazione Inferiore alla Complessità dell’Ordinamento per Confronto• Corollario: Il merge sort è un algoritmo di

ordinamento basato su confronti asintoticamente ottimo.

88


89Esercizi

• Esercizio 1Dato un array A[1..n] di interi e un intero v,

scrivere un programma C++ che determini se esistono due elementi in A la cui somma è esattamente v

• Esercizio 2Siano date n monete d'oro, tutte dello stesso

peso tranne una contraffatta che pesa meno, ed una bilancia con due piatti. Delineare un algoritmo per individuare la moneta contraffatta in al più log n pesate.

Documents

Algoritmi e Calcolo Parallelo 2012/2013 - Analisi degli Algoritmi