diff --git a/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Dispense - Esercizio 1.mod b/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Dispense - Esercizio 1.mod
new file mode 100644
index 0000000..0931cce
--- /dev/null
+++ b/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Dispense - Esercizio 1.mod	
@@ -0,0 +1,21 @@
+/* Primale */
+var x;
+var y;
+
+maximize s: x + y;
+c1: 2*x + y <= 5;
+c2: x + 2*y <= 5;
+
+/* Duale */
+var a;
+var b;
+
+minimize z: 5*a + 5*b;
+c3: 2*a + b >= 1;
+c4: a + 2*b >= 1;
+
+solve;
+display x, y, s;
+display a, b, z;
+
+end;
diff --git a/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Dispense - Esercizio 2.mod b/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Dispense - Esercizio 2.mod
new file mode 100644
index 0000000..d9c3166
--- /dev/null
+++ b/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Dispense - Esercizio 2.mod	
@@ -0,0 +1,13 @@
+var w >= 0;
+var x >= 0;
+var y >= 0;
+var z >= 0;
+
+maximize sol: 3*w - 2*x + z;
+c1: w - x + 3*y >= 8;
+c2: 4*x + 5*z <= 12;
+c3: 3*w - 4*y + z >= 15;
+
+solve;
+display sol, w, x, y, z;
+end;
diff --git a/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Dispense - Esercizio giacenza.mod b/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Dispense - Esercizio giacenza.mod
new file mode 100644
index 0000000..a4e200b
--- /dev/null
+++ b/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Dispense - Esercizio giacenza.mod	
@@ -0,0 +1,75 @@
+/*
+Un grossista gestisce nel suo magazzino P tipi di prodotti differenti.
+- [x] Ogni prodotto k = 1..P ha un volume di v_k unità.
+- [x] Ogni prodotto ha una domanda stimata, per le prossime T settimane, pari a d_{tk} (t = 1..T).
+- [x] L'approvigionamento di ogni prodotto k è limitato a un massimo di m_k unità per settimana.
+- [x] Il volume totale disponibile nel magazzino è pari a V.
+- [x] Ogni prodotto k non può occupare più di V_k unità di spazio in magazzino.
+- [x] Alla settimana t = 0 il magazzino dispone di I_{0k} unità di ogni prodotto k.
+- [x] Alla fine della settimana T devono rimanere in magazzino s_k unità di ogni prodotto k.
+- [x] In ogni settimana si può ordinare (o meno) ogni prodotto k al rispettivo fornitore.
+- [x] Il prodotto viene consegnato al magazzino nella stessa settimana.
+- [x] Ogni ordine di prodotto k non può essere inferiore a una data quantità minima q_k.
+
+Si scriva un modello di programmazione lineare per aiutare l'azienda a definire una politica di approvigionamento che permetta di soddisfare la domanda, nel rispetto di tutti i vincoli e minimizzando la giacenza media delle T settimane.
+*/
+
+# Numero di prodotti
+param P;
+
+# Numero di settimane
+param T;
+
+# Domanda per ogni prodotto
+param domanda{1 .. P, 1 .. T}, >= 0;
+
+# Offerta per ogni prodotto
+param approvigionamento{1 .. P}, >= 0;
+
+# Quantità in magazzino di ogni prodotto alla settimana 0
+param quantitaIniziale{1 .. P}, >= 0;
+
+# Capacità in magazzino massima di ogni prodotto
+param capacita{1 .. P}, >= 0;
+
+# Capacità massima in totale
+param capacitaTotale, >= 0;
+
+# Quantità minima di ogni prodotto che deve rimanere in magazzino alla fine dell'ultima settimana
+param safety{1 .. P}, >= 0;
+
+# Dimensione minima di un ordine
+param ordineMinimo{1 .. P}, >= 0;
+
+# Quantità da ordinare ogni settimana di ogni prodotto
+var ordine{1 .. P, 1 .. T}, >= 0;
+
+# Quantità in magazzino di ogni prodotto
+var quantita{1 .. P, 1 .. T}, >= 0;
+
+# Quantità totale di prodotti in magazzino
+var quantitaTotale{1 .. T}, >= 0;
+
+
+# All'ultima settimana, la quantità deve essere almeno safety
+c1{p in 1 .. P}: safety[p] <= quantita[p, T];
+
+# La quantità di ogni prodotto deve sempre essere minore della capacità e la safety.
+c2{p in 1 .. P, t in 1 .. T}: quantita[p, t] <= capacita[p];
+
+# Ci possono essere massimo X prodotti in magazzino.
+c3{t in 1 .. T}: quantitaTotale[t] == sum{p in 1 .. P} quantita[p, t];
+c4{t in 1 .. T}: quantitaTotale[t] <= capacitaTotale;
+
+# Si può ordinare al minimo X e al massimo Y prodotti ogni settimana
+c5{p in 1 .. P, t in 1 .. T}: ordine[p, t] >= ordineMinimo[p];
+c6{p in 1 .. P, t in 1 .. T}: ordine[p, t] <= approvigionamento[p];
+
+# La quantità è uguale alla somma degli ordini e della quantità iniziale
+c7{p in 1 .. P, t in 1 .. T}: quantita[p, t] == quantitaIniziale[p] + sum{u in 1 .. t} ordine[p, u] - sum{u in 1 .. t} domanda[p, u];
+
+# Funzione obiettivo
+minimize sol: sum{t in 1 .. T} quantitaTotale[t];
+solve;
+
+end;
diff --git a/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Esame 2020-06-08 - Esercizio 2.mod b/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Esame 2020-06-08 - Esercizio 2.mod
new file mode 100644
index 0000000..4ea9a12
--- /dev/null
+++ b/4 - Ottimizzazione lineare intera/1 - Esercizi svolti/Esame 2020-06-08 - Esercizio 2.mod	
@@ -0,0 +1,39 @@
+/*
+A warehouse has to store n boxes in a rack with m shelves.
+The first m1 shelves have length L1, while the remaining have length L2.
+Each box j = 1..n has length l_j and a frequency of usage f_j.
+Write a linear programming model that helps the warehouse to decide how to store the boxes, 
+so that the sum of the frequencies of the boxes stored in the first m1 shelves is maximized.
+(N.B. It is not known if all the boxes can be stored.)
+*/
+
+# Set casse
+param nCasse >= 1;
+set CASSE := 1..nCasse;
+
+# Set scaffali
+param nScaffali >= 1;
+set SCAFFALI := 1..nScaffali;
+
+# Parametri cassa
+param dimensione{c in CASSE} >= 0;
+param frequenza{c in CASSE} >= 0;
+
+# Parametri scaffali
+param spazioA >= 0;
+param spazioB >= 0;
+param cutoff >= 1, <= nScaffali + 1;  # Tutti gli scaffali maggiori o uguali a questo numero saranno considerati nel set B
+param spazio{s in SCAFFALI} := if s >= cutoff then spazioB else spazioA;
+set SCAFFALI_A := 1..cutoff;
+set SCAFFALI_B := cutoff + 1 ..nScaffali;
+
+# Vincoli
+var suScaffale{c in CASSE, s in SCAFFALI} binary;
+c1{c in CASSE}: sum{s in SCAFFALI} suScaffale[c, s] == 1;
+c2{s in SCAFFALI}: sum{c in CASSE} dimensione[c] * suScaffale[c, s] <= spazio[s];
+
+# Funzione obiettivo
+maximize z: sum{c in CASSE, s in SCAFFALI_A} suScaffale[c, s] * frequenza[c];
+
+solve;
+end;