====== Esercitazione 1 ======

===== Esercizio 0: Getting started -- Preprocessing, compilazione e linking =====
0.1) Compilare ed eseguire il seguente programma:
<code c>
#include <stdio.h>
#include <math.h>

int main (void) {
  double x=3.0;

  printf("Radice = %f\n",sqrt(x));
  return 0;
}
</code>
salvato nel file //ff.c// con
<code>
gcc -Wall -pedantic ff.c
</code>
Chi segnala un errore? E' fallita la fase di preprocessing, la compilazione o il linking? Cosa contine il modulo oggetto se specifico l'opzione -c? Come si risolve il problema?

0.2) Cosa accade se eliminiamo la linea
<code c>
#include <math.h>
</code>
? A questo punto cosa va storto? Sapete interpretare i messaggi a video e stabilire chi li ha scritti e perche'? Viene generato l'eseguibile?

0.3) Generare il modulo oggetto. Utilizzare //objdump, nm, readelf// per capire cosa contengono la tabella di rilocazione, la tabella dei simboli esportati ed esterni, le sezioni data, BSS e codice.

0.4) Usare l'opzione //-E// e la //-S// del gcc: che cosa succede? Cosa accade specificando il flag -g assieme a -S? Che cosa e' accaduto?

===== Esercizio 1. Invasion Percolation =====
Invasion percolation e' una semplice forma frattale basata su un modello di diffusione di fluidi. In due dimensioni, l'invasion percolation si simula come segue.\\

**(Passo 1)** Dati N ed r, si genera una griglia quadrata NxN di numeri casuali nel range [1,r] . Ad esempio, una griglia 5x5 di numeri nel range [1,100] puo' essere:
 
||26 |	17 	|72 	 |45  | 38  ||
||10 |	38 	|39 	 |92  |	38  ||
||44 |  27 	|12 	 |29  | 77  ||
||61 |	26 	|90 	 |35  | 11  ||
||83 |  84 	|18      |56  | 52  ||

**(Passo 2)** poi si marca il centro della griglia come `pieno' ad esempio (8-) indica la cella piena):
 
||26 |	17 	|72 	 |45  | 38  ||
||10 |	38 	|39 	 |92  |	38  ||
||44 |  27 	|8-)	 |29  | 77  ||
||61 |	26 	|90 	 |35  | 11  ||
||83 |  84 	|18      |56  | 52  ||

**(Passo 3)** Si effettua un ciclo in cui ad ogni passo: 
  - si esaminano i vicini di tutte le celle gia' piene (gia' marcate con 8-)), 
  - si sceglie la cella **c** con il valore minore e 
  - si marca **c** con come 'piena'.
Finche' il 50% le celle dela griglia sono state marcate come piene.
 

Ad esempio, al primo passo i quattro vicini della cella (2,2) nella nostra griglia sono 39,29,90,29 indicati in grassetto:

||26 |	17 	|72 	 |45  | 38  ||
||10 |	38 	|**39** 	 |92  |	38  ||
||44 |  **27** 	|8-)	 |**29**  | 77  ||
||61 |	26 	|**90** 	 |35  | 11  ||
||83 |  84 	|18      |56  | 52  ||
  	  	  	  	 
 
Quindi scegliamo 27. L'evoluzione della forma frattale e' : (8-) indica la cella selezionata ad ogni nuovo passo, mentre i vicini sono indicati in grassetto)

||26 |	17 	|72 	 |45  | 38  ||
||10 |	**38**	|**39** 	 |92  |	38  ||
||**44** |  8-) 	|8-)	 |**29**  | 77  ||
||61 |	**26** 	|**90** 	 |35  | 11  ||
||83 |  84 	|18      |56  | 52  ||

||26 |	17 	|72 	 |45  | 38  ||
||10 |	**38**	|**39** 	 |92  |	38  ||
||**44** |  8-) 	|8-)	 |**29**  | 77  ||
||**61** |	 8-) |**90** 	 |35  | 11  ||
||83 |  **84**	|18      |56  | 52  ||


||26 |	17 	|72 	 |45  | 38  ||
||10 |	**38**	|**39** 	 |**92**  |	38  ||
||**44** |  8-) 	|8-)	 |8-)  | **77**  ||
||**61** |	 8-) |**90** 	 |**35**  | 11  ||
||83 |  **84**	|18      |56  | 52  ||


Si richiede di implementare il comando
<code>
percolation N r
</code>
che simula //invasion percolation// su una griglia NxN con valori nel range [1..r].
Ogni iterazione viene visualizzata sullo schermo a intervalli di 1sec. La computazione si ferma quando il 50% delle celle e' stata marcata.

Le funzioni che compongono il programma devono essere opportunamente testate in modo automatico (con adeguati programmi di test).

//ATTENZIONE: Le matrici **devono** essere rappresentate come array di puntatori a righe. Per i numeri casuali e' sufficiente usare le funzioni della libreria standard. Per pulire lo schermo fra una stampa e l'altra si puo' usare ''system("clear")''.//

===== Esercizio 2: Compilazione separata e Makefile =====
Suddividere il programma C relativo all'esercizio 1 in piu' file in modo che:
  * il ''main()'' sia contenuto in un file ''main.c''
  * le altre funzioni siano suddivise in almeno altri due file ''.c''

Predisporre gli opportuni file ''.h'' e le inclusioni necessari per una corretta compilazione.

Sviluppare inoltre un ''makefile'' che contenga almeno i seguenti target:
  * un target per ciascun modulo oggetto
  * un target **percolation** che permette di ricreare l'eseguibile a partire dai moduli oggetto
  * un target **test** che esegue i test automatici e ne comunica l'esito
  * un target **cleanall** che elimina i file di core e gli oggetti della compilazione.