From 5b584e2a8c451c1ef84cccd2dfbf657e766c0dab Mon Sep 17 00:00:00 2001
From: Axel <axelrubini@gmail.com>
Date: Mon, 2 Mar 2026 15:57:09 +0100
Subject: [PATCH] Axel's exams solustions

---
 exams/AxelRubini/2025-01-09/1/Makefile        |  10 +
 exams/AxelRubini/2025-01-09/1/include/DES.hpp | 212 +++++++++
 .../2025-01-09/1/include/Decision.hpp         | 266 +++++++++++
 .../2025-01-09/1/include/Dynamics.hpp         | 214 +++++++++
 .../2025-01-09/1/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-01-09/1/include/IO.hpp  | 150 +++++++
 .../2025-01-09/1/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-01-09/1/include/Queue.hpp |  70 +++
 .../2025-01-09/1/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-01-09/1/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-01-09/1/main            | Bin 0 -> 44208 bytes
 exams/AxelRubini/2025-01-09/1/main.cpp        |  42 ++
 exams/AxelRubini/2025-01-09/1/parameters.txt  |  11 +
 exams/AxelRubini/2025-01-09/1/results.txt     |   2 +
 exams/AxelRubini/2025-01-09/2/Makefile        |  10 +
 exams/AxelRubini/2025-01-09/2/include/DES.hpp | 212 +++++++++
 .../2025-01-09/2/include/Decision.hpp         | 266 +++++++++++
 .../2025-01-09/2/include/Dynamics.hpp         | 214 +++++++++
 .../2025-01-09/2/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-01-09/2/include/IO.hpp  | 150 +++++++
 .../2025-01-09/2/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-01-09/2/include/Queue.hpp |  70 +++
 .../2025-01-09/2/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-01-09/2/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-01-09/2/main            | Bin 0 -> 44376 bytes
 exams/AxelRubini/2025-01-09/2/main.cpp        |  44 ++
 exams/AxelRubini/2025-01-09/2/parameters.txt  |  12 +
 exams/AxelRubini/2025-01-09/2/results.txt     |   2 +
 exams/AxelRubini/2025-01-09/3/Makefile        |  10 +
 exams/AxelRubini/2025-01-09/3/include/DES.hpp | 212 +++++++++
 .../2025-01-09/3/include/Decision.hpp         | 266 +++++++++++
 .../2025-01-09/3/include/Dynamics.hpp         | 214 +++++++++
 .../2025-01-09/3/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-01-09/3/include/IO.hpp  | 150 +++++++
 .../2025-01-09/3/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-01-09/3/include/Queue.hpp |  70 +++
 .../2025-01-09/3/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-01-09/3/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-01-09/3/main            | Bin 0 -> 73624 bytes
 exams/AxelRubini/2025-01-09/3/main.cpp        | 133 ++++++
 exams/AxelRubini/2025-01-09/3/parameters.txt  |   2 +
 exams/AxelRubini/2025-01-09/3/results.txt     |   3 +
 exams/AxelRubini/2025-01-09/4/Makefile        |  10 +
 exams/AxelRubini/2025-01-09/4/include/DES.hpp | 212 +++++++++
 .../2025-01-09/4/include/Decision.hpp         | 266 +++++++++++
 .../2025-01-09/4/include/Dynamics.hpp         | 214 +++++++++
 .../2025-01-09/4/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-01-09/4/include/IO.hpp  | 150 +++++++
 .../2025-01-09/4/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-01-09/4/include/Queue.hpp |  70 +++
 .../2025-01-09/4/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-01-09/4/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-01-09/4/main            | Bin 0 -> 78288 bytes
 exams/AxelRubini/2025-01-09/4/main.cpp        | 191 ++++++++
 exams/AxelRubini/2025-01-09/4/parameters.txt  |   3 +
 exams/AxelRubini/2025-01-09/4/results.txt     |   9 +
 exams/AxelRubini/2025-01-09/5/Makefile        |  10 +
 exams/AxelRubini/2025-01-09/5/include/DES.hpp | 212 +++++++++
 .../2025-01-09/5/include/Decision.hpp         | 266 +++++++++++
 .../2025-01-09/5/include/Dynamics.hpp         | 214 +++++++++
 .../2025-01-09/5/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-01-09/5/include/IO.hpp  | 150 +++++++
 .../2025-01-09/5/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-01-09/5/include/Queue.hpp |  70 +++
 .../2025-01-09/5/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-01-09/5/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-01-09/5/main            | Bin 0 -> 87256 bytes
 exams/AxelRubini/2025-01-09/5/main.cpp        | 235 ++++++++++
 exams/AxelRubini/2025-01-09/5/parameters.txt  |   3 +
 exams/AxelRubini/2025-01-09/5/results.txt     |  12 +
 exams/AxelRubini/2025-02-05/1/Makefile        |  10 +
 exams/AxelRubini/2025-02-05/1/include/DES.hpp | 212 +++++++++
 .../2025-02-05/1/include/Decision.hpp         | 266 +++++++++++
 .../2025-02-05/1/include/Dynamics.hpp         | 214 +++++++++
 .../2025-02-05/1/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-02-05/1/include/IO.hpp  | 150 +++++++
 .../2025-02-05/1/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-02-05/1/include/Queue.hpp |  70 +++
 .../2025-02-05/1/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-02-05/1/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-02-05/1/main            | Bin 0 -> 76608 bytes
 exams/AxelRubini/2025-02-05/1/main.cpp        | 165 +++++++
 exams/AxelRubini/2025-02-05/1/parameters.txt  |   9 +
 exams/AxelRubini/2025-02-05/1/results.txt     |   6 +
 exams/AxelRubini/2025-02-05/2/Makefile        |  10 +
 exams/AxelRubini/2025-02-05/2/include/DES.hpp | 212 +++++++++
 .../2025-02-05/2/include/Decision.hpp         | 266 +++++++++++
 .../2025-02-05/2/include/Dynamics.hpp         | 214 +++++++++
 .../2025-02-05/2/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-02-05/2/include/IO.hpp  | 150 +++++++
 .../2025-02-05/2/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-02-05/2/include/Queue.hpp |  70 +++
 .../2025-02-05/2/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-02-05/2/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-02-05/2/main            | Bin 0 -> 44016 bytes
 exams/AxelRubini/2025-02-05/2/main.cpp        | 187 ++++++++
 exams/AxelRubini/2025-02-05/2/parameters.txt  |  10 +
 exams/AxelRubini/2025-02-05/2/results.txt     |   2 +
 exams/AxelRubini/2025-02-05/3/Makefile        |  10 +
 exams/AxelRubini/2025-02-05/3/include/DES.hpp | 212 +++++++++
 .../2025-02-05/3/include/Decision.hpp         | 266 +++++++++++
 .../2025-02-05/3/include/Dynamics.hpp         | 214 +++++++++
 .../2025-02-05/3/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-02-05/3/include/IO.hpp  | 150 +++++++
 .../2025-02-05/3/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-02-05/3/include/Queue.hpp |  70 +++
 .../2025-02-05/3/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-02-05/3/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-02-05/3/main            | Bin 0 -> 43304 bytes
 exams/AxelRubini/2025-02-05/3/main.cpp        | 188 ++++++++
 exams/AxelRubini/2025-02-05/3/parameters.txt  |  11 +
 exams/AxelRubini/2025-02-05/3/results.txt     |   2 +
 exams/AxelRubini/2025-02-05/4/Makefile        |  10 +
 exams/AxelRubini/2025-02-05/4/include/DES.hpp | 212 +++++++++
 .../2025-02-05/4/include/Decision.hpp         | 266 +++++++++++
 .../2025-02-05/4/include/Dynamics.hpp         | 214 +++++++++
 .../2025-02-05/4/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-02-05/4/include/IO.hpp  | 150 +++++++
 .../2025-02-05/4/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-02-05/4/include/Queue.hpp |  70 +++
 .../2025-02-05/4/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-02-05/4/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-02-05/4/main            | Bin 0 -> 43440 bytes
 exams/AxelRubini/2025-02-05/4/main.cpp        | 150 +++++++
 exams/AxelRubini/2025-02-05/4/parameters.txt  |  11 +
 exams/AxelRubini/2025-02-05/4/results.txt     |   2 +
 exams/AxelRubini/2025-02-05/5/Makefile        |  10 +
 exams/AxelRubini/2025-02-05/5/include/DES.hpp | 212 +++++++++
 .../2025-02-05/5/include/Decision.hpp         | 266 +++++++++++
 .../2025-02-05/5/include/Dynamics.hpp         | 214 +++++++++
 .../2025-02-05/5/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-02-05/5/include/IO.hpp  | 150 +++++++
 .../2025-02-05/5/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-02-05/5/include/Queue.hpp |  70 +++
 .../2025-02-05/5/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-02-05/5/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-02-05/5/main            | Bin 0 -> 43448 bytes
 exams/AxelRubini/2025-02-05/5/main.cpp        | 152 +++++++
 exams/AxelRubini/2025-02-05/5/parameters.txt  |  12 +
 exams/AxelRubini/2025-02-05/5/results.txt     |   2 +
 exams/AxelRubini/2025-03-21/1/Makefile        |  10 +
 exams/AxelRubini/2025-03-21/1/include/DES.hpp | 212 +++++++++
 .../2025-03-21/1/include/Decision.hpp         | 266 +++++++++++
 .../2025-03-21/1/include/Dynamics.hpp         | 214 +++++++++
 .../2025-03-21/1/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-03-21/1/include/IO.hpp  | 150 +++++++
 .../2025-03-21/1/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-03-21/1/include/Queue.hpp |  70 +++
 .../2025-03-21/1/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-03-21/1/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-03-21/1/main            | Bin 0 -> 43512 bytes
 exams/AxelRubini/2025-03-21/1/main.cpp        |  98 ++++
 exams/AxelRubini/2025-03-21/1/parameters.txt  |   5 +
 exams/AxelRubini/2025-03-21/1/results.txt     |   4 +
 exams/AxelRubini/2025-03-21/2/Makefile        |  10 +
 exams/AxelRubini/2025-03-21/2/include/DES.hpp | 212 +++++++++
 .../2025-03-21/2/include/Decision.hpp         | 266 +++++++++++
 .../2025-03-21/2/include/Dynamics.hpp         | 214 +++++++++
 .../2025-03-21/2/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-03-21/2/include/IO.hpp  | 150 +++++++
 .../2025-03-21/2/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-03-21/2/include/Queue.hpp |  70 +++
 .../2025-03-21/2/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-03-21/2/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-03-21/2/main            | Bin 0 -> 43504 bytes
 exams/AxelRubini/2025-03-21/2/main.cpp        | 124 +++++
 exams/AxelRubini/2025-03-21/2/parameters.txt  |   5 +
 exams/AxelRubini/2025-03-21/2/results.txt     |   3 +
 exams/AxelRubini/2025-03-21/3/Makefile        |  10 +
 exams/AxelRubini/2025-03-21/3/include/DES.hpp | 212 +++++++++
 .../2025-03-21/3/include/Decision.hpp         | 266 +++++++++++
 .../2025-03-21/3/include/Dynamics.hpp         | 214 +++++++++
 .../2025-03-21/3/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-03-21/3/include/IO.hpp  | 150 +++++++
 .../2025-03-21/3/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-03-21/3/include/Queue.hpp |  70 +++
 .../2025-03-21/3/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-03-21/3/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-03-21/3/main            | Bin 0 -> 47248 bytes
 exams/AxelRubini/2025-03-21/3/main.cpp        | 104 +++++
 exams/AxelRubini/2025-03-21/3/parameters.txt  |   6 +
 exams/AxelRubini/2025-03-21/3/results.txt     |   3 +
 exams/AxelRubini/2025-03-21/4/Makefile        |  10 +
 exams/AxelRubini/2025-03-21/4/include/DES.hpp | 212 +++++++++
 .../2025-03-21/4/include/Decision.hpp         | 266 +++++++++++
 .../2025-03-21/4/include/Dynamics.hpp         | 214 +++++++++
 .../2025-03-21/4/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-03-21/4/include/IO.hpp  | 150 +++++++
 .../2025-03-21/4/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-03-21/4/include/Queue.hpp |  70 +++
 .../2025-03-21/4/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-03-21/4/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-03-21/4/main            | Bin 0 -> 47248 bytes
 exams/AxelRubini/2025-03-21/4/main.cpp        | 102 +++++
 exams/AxelRubini/2025-03-21/4/parameters.txt  |   6 +
 exams/AxelRubini/2025-03-21/4/results.txt     |   3 +
 exams/AxelRubini/2025-03-21/5/Makefile        |  10 +
 exams/AxelRubini/2025-03-21/5/include/DES.hpp | 212 +++++++++
 .../2025-03-21/5/include/Decision.hpp         | 266 +++++++++++
 .../2025-03-21/5/include/Dynamics.hpp         | 214 +++++++++
 .../2025-03-21/5/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-03-21/5/include/IO.hpp  | 150 +++++++
 .../2025-03-21/5/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-03-21/5/include/Queue.hpp |  70 +++
 .../2025-03-21/5/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-03-21/5/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-03-21/5/main            | Bin 0 -> 47432 bytes
 exams/AxelRubini/2025-03-21/5/main.cpp        | 124 +++++
 exams/AxelRubini/2025-03-21/5/parameters.txt  |   5 +
 exams/AxelRubini/2025-03-21/5/results.txt     |   5 +
 exams/AxelRubini/2025-06-12/1/Makefile        |  10 +
 exams/AxelRubini/2025-06-12/1/include/DES.hpp | 212 +++++++++
 .../2025-06-12/1/include/Decision.hpp         | 266 +++++++++++
 .../2025-06-12/1/include/Dynamics.hpp         | 214 +++++++++
 .../2025-06-12/1/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-06-12/1/include/IO.hpp  | 150 +++++++
 .../2025-06-12/1/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-06-12/1/include/Queue.hpp |  70 +++
 .../2025-06-12/1/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-06-12/1/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-06-12/1/main            | Bin 0 -> 38904 bytes
 exams/AxelRubini/2025-06-12/1/main.cpp        |  51 +++
 exams/AxelRubini/2025-06-12/1/parameters.txt  |   4 +
 exams/AxelRubini/2025-06-12/1/results.txt     |   7 +
 exams/AxelRubini/2025-06-12/2/Makefile        |   7 +
 exams/AxelRubini/2025-06-12/2/include/DES.hpp | 212 +++++++++
 .../2025-06-12/2/include/Decision.hpp         | 266 +++++++++++
 .../2025-06-12/2/include/Dynamics.hpp         | 214 +++++++++
 .../2025-06-12/2/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-06-12/2/include/IO.hpp  | 150 +++++++
 .../2025-06-12/2/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-06-12/2/include/Queue.hpp |  70 +++
 .../2025-06-12/2/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-06-12/2/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-06-12/2/main            | Bin 0 -> 43352 bytes
 exams/AxelRubini/2025-06-12/2/main.cpp        | 103 +++++
 exams/AxelRubini/2025-06-12/2/parameters.txt  |   6 +
 exams/AxelRubini/2025-06-12/2/results.txt     |   2 +
 exams/AxelRubini/2025-06-12/3/Makefile        |  10 +
 exams/AxelRubini/2025-06-12/3/include/DES.hpp | 212 +++++++++
 .../2025-06-12/3/include/Decision.hpp         | 266 +++++++++++
 .../2025-06-12/3/include/Dynamics.hpp         | 214 +++++++++
 .../2025-06-12/3/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-06-12/3/include/IO.hpp  | 150 +++++++
 .../2025-06-12/3/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-06-12/3/include/Queue.hpp |  70 +++
 .../2025-06-12/3/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-06-12/3/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-06-12/3/main            | Bin 0 -> 39088 bytes
 exams/AxelRubini/2025-06-12/3/main.cpp        |  33 ++
 exams/AxelRubini/2025-06-12/3/parameters.txt  |   5 +
 exams/AxelRubini/2025-06-12/3/results.txt     |  12 +
 exams/AxelRubini/2025-06-12/4/Makefile        |   7 +
 exams/AxelRubini/2025-06-12/4/include/DES.hpp | 212 +++++++++
 .../2025-06-12/4/include/Decision.hpp         | 266 +++++++++++
 .../2025-06-12/4/include/Dynamics.hpp         | 214 +++++++++
 .../2025-06-12/4/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-06-12/4/include/IO.hpp  | 150 +++++++
 .../2025-06-12/4/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-06-12/4/include/Queue.hpp |  70 +++
 .../2025-06-12/4/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-06-12/4/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-06-12/4/main            | Bin 0 -> 44192 bytes
 exams/AxelRubini/2025-06-12/4/main.cpp        | 100 +++++
 exams/AxelRubini/2025-06-12/4/parameters.txt  |  11 +
 exams/AxelRubini/2025-06-12/4/results.txt     |   2 +
 exams/AxelRubini/2025-06-12/5/Makefile        |   7 +
 exams/AxelRubini/2025-06-12/5/include/DES.hpp | 212 +++++++++
 .../2025-06-12/5/include/Decision.hpp         | 266 +++++++++++
 .../2025-06-12/5/include/Dynamics.hpp         | 214 +++++++++
 .../2025-06-12/5/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-06-12/5/include/IO.hpp  | 150 +++++++
 .../2025-06-12/5/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-06-12/5/include/Queue.hpp |  70 +++
 .../2025-06-12/5/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-06-12/5/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-06-12/5/main            | Bin 0 -> 48288 bytes
 exams/AxelRubini/2025-06-12/5/main.cpp        | 116 +++++
 exams/AxelRubini/2025-06-12/5/parameters.txt  |  11 +
 exams/AxelRubini/2025-06-12/5/results.txt     |   2 +
 exams/AxelRubini/2025-07-08/1/Makefile        |  10 +
 exams/AxelRubini/2025-07-08/1/include/DES.hpp | 212 +++++++++
 .../2025-07-08/1/include/Decision.hpp         | 266 +++++++++++
 .../2025-07-08/1/include/Dynamics.hpp         | 214 +++++++++
 .../2025-07-08/1/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-07-08/1/include/IO.hpp  | 150 +++++++
 .../2025-07-08/1/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-07-08/1/include/Queue.hpp |  70 +++
 .../2025-07-08/1/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-07-08/1/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-07-08/1/main            | Bin 0 -> 43808 bytes
 exams/AxelRubini/2025-07-08/1/main.cpp        | 149 ++++++
 exams/AxelRubini/2025-07-08/1/parameters.txt  |   7 +
 exams/AxelRubini/2025-07-08/1/results.txt     |   2 +
 exams/AxelRubini/2025-07-08/2/Makefile        |  10 +
 exams/AxelRubini/2025-07-08/2/include/DES.hpp | 212 +++++++++
 .../2025-07-08/2/include/Decision.hpp         | 266 +++++++++++
 .../2025-07-08/2/include/Dynamics.hpp         | 214 +++++++++
 .../2025-07-08/2/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-07-08/2/include/IO.hpp  | 150 +++++++
 .../2025-07-08/2/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-07-08/2/include/Queue.hpp |  70 +++
 .../2025-07-08/2/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-07-08/2/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-07-08/2/main            | Bin 0 -> 43664 bytes
 exams/AxelRubini/2025-07-08/2/main.cpp        | 123 +++++
 exams/AxelRubini/2025-07-08/2/parameters.txt  |   7 +
 exams/AxelRubini/2025-07-08/2/results.txt     |   3 +
 exams/AxelRubini/2025-07-08/3/Makefile        |  10 +
 exams/AxelRubini/2025-07-08/3/include/DES.hpp | 212 +++++++++
 .../2025-07-08/3/include/Decision.hpp         | 266 +++++++++++
 .../2025-07-08/3/include/Dynamics.hpp         | 214 +++++++++
 .../2025-07-08/3/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-07-08/3/include/IO.hpp  | 150 +++++++
 .../2025-07-08/3/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-07-08/3/include/Queue.hpp |  70 +++
 .../2025-07-08/3/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-07-08/3/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-07-08/3/main            | Bin 0 -> 44192 bytes
 exams/AxelRubini/2025-07-08/3/main.cpp        | 127 ++++++
 exams/AxelRubini/2025-07-08/3/parameters.txt  |  12 +
 exams/AxelRubini/2025-07-08/3/results.txt     |   2 +
 exams/AxelRubini/2025-07-08/4/Makefile        |  10 +
 exams/AxelRubini/2025-07-08/4/include/DES.hpp | 212 +++++++++
 .../2025-07-08/4/include/Decision.hpp         | 266 +++++++++++
 .../2025-07-08/4/include/Dynamics.hpp         | 214 +++++++++
 .../2025-07-08/4/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-07-08/4/include/IO.hpp  | 150 +++++++
 .../2025-07-08/4/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-07-08/4/include/Queue.hpp |  70 +++
 .../2025-07-08/4/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-07-08/4/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-07-08/4/main            | Bin 0 -> 48536 bytes
 exams/AxelRubini/2025-07-08/4/main.cpp        | 137 ++++++
 exams/AxelRubini/2025-07-08/4/parameters.txt  |  12 +
 exams/AxelRubini/2025-07-08/4/results.txt     |   3 +
 exams/AxelRubini/2025-07-08/5/Makefile        |  10 +
 exams/AxelRubini/2025-07-08/5/include/DES.hpp | 212 +++++++++
 .../2025-07-08/5/include/Decision.hpp         | 266 +++++++++++
 .../2025-07-08/5/include/Dynamics.hpp         | 214 +++++++++
 .../2025-07-08/5/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-07-08/5/include/IO.hpp  | 150 +++++++
 .../2025-07-08/5/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-07-08/5/include/Queue.hpp |  70 +++
 .../2025-07-08/5/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-07-08/5/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-07-08/5/main            | Bin 0 -> 48288 bytes
 exams/AxelRubini/2025-07-08/5/main.cpp        | 135 ++++++
 exams/AxelRubini/2025-07-08/5/parameters.txt  |  12 +
 exams/AxelRubini/2025-07-08/5/results.txt     |   4 +
 exams/AxelRubini/2025-09-08/1/Makefile        |  10 +
 exams/AxelRubini/2025-09-08/1/include/DES.hpp | 212 +++++++++
 .../2025-09-08/1/include/Decision.hpp         | 266 +++++++++++
 .../2025-09-08/1/include/Dynamics.hpp         | 214 +++++++++
 .../2025-09-08/1/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-09-08/1/include/IO.hpp  | 150 +++++++
 .../2025-09-08/1/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-09-08/1/include/Queue.hpp |  70 +++
 .../2025-09-08/1/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-09-08/1/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-09-08/1/main            | Bin 0 -> 43968 bytes
 exams/AxelRubini/2025-09-08/1/main.cpp        |  93 ++++
 exams/AxelRubini/2025-09-08/1/parameters.txt  |   8 +
 exams/AxelRubini/2025-09-08/1/results.txt     |   2 +
 exams/AxelRubini/2025-09-08/2/Makefile        |  10 +
 exams/AxelRubini/2025-09-08/2/include/DES.hpp | 212 +++++++++
 .../2025-09-08/2/include/Decision.hpp         | 266 +++++++++++
 .../2025-09-08/2/include/Dynamics.hpp         | 214 +++++++++
 .../2025-09-08/2/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-09-08/2/include/IO.hpp  | 150 +++++++
 .../2025-09-08/2/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-09-08/2/include/Queue.hpp |  70 +++
 .../2025-09-08/2/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-09-08/2/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-09-08/2/main            | Bin 0 -> 43840 bytes
 exams/AxelRubini/2025-09-08/2/main.cpp        | 120 +++++
 exams/AxelRubini/2025-09-08/2/parameters.txt  |   8 +
 exams/AxelRubini/2025-09-08/2/results.txt     |   2 +
 exams/AxelRubini/2025-09-08/3/Makefile        |  10 +
 exams/AxelRubini/2025-09-08/3/include/DES.hpp | 212 +++++++++
 .../2025-09-08/3/include/Decision.hpp         | 266 +++++++++++
 .../2025-09-08/3/include/Dynamics.hpp         | 214 +++++++++
 .../2025-09-08/3/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-09-08/3/include/IO.hpp  | 150 +++++++
 .../2025-09-08/3/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-09-08/3/include/Queue.hpp |  70 +++
 .../2025-09-08/3/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-09-08/3/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-09-08/3/main            | Bin 0 -> 47896 bytes
 exams/AxelRubini/2025-09-08/3/main.cpp        | 105 +++++
 exams/AxelRubini/2025-09-08/3/parameters.txt  |  12 +
 exams/AxelRubini/2025-09-08/3/results.txt     |   2 +
 exams/AxelRubini/2025-09-08/4/Makefile        |  10 +
 exams/AxelRubini/2025-09-08/4/include/DES.hpp | 212 +++++++++
 .../2025-09-08/4/include/Decision.hpp         | 266 +++++++++++
 .../2025-09-08/4/include/Dynamics.hpp         | 214 +++++++++
 .../2025-09-08/4/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-09-08/4/include/IO.hpp  | 150 +++++++
 .../2025-09-08/4/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-09-08/4/include/Queue.hpp |  70 +++
 .../2025-09-08/4/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-09-08/4/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-09-08/4/main            | Bin 0 -> 47952 bytes
 exams/AxelRubini/2025-09-08/4/main.cpp        | 119 +++++
 exams/AxelRubini/2025-09-08/4/parameters.txt  |  12 +
 exams/AxelRubini/2025-09-08/4/results.txt     |   4 +
 exams/AxelRubini/2025-09-08/5/Makefile        |  10 +
 exams/AxelRubini/2025-09-08/5/include/DES.hpp | 212 +++++++++
 .../2025-09-08/5/include/Decision.hpp         | 266 +++++++++++
 .../2025-09-08/5/include/Dynamics.hpp         | 214 +++++++++
 .../2025-09-08/5/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-09-08/5/include/IO.hpp  | 150 +++++++
 .../2025-09-08/5/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-09-08/5/include/Queue.hpp |  70 +++
 .../2025-09-08/5/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-09-08/5/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-09-08/5/main            | Bin 0 -> 47896 bytes
 exams/AxelRubini/2025-09-08/5/main.cpp        | 120 +++++
 exams/AxelRubini/2025-09-08/5/parameters.txt  |  11 +
 exams/AxelRubini/2025-09-08/5/results.txt     |   5 +
 exams/AxelRubini/2025-11-03/1/Makefile        |  10 +
 exams/AxelRubini/2025-11-03/1/include/DES.hpp | 212 +++++++++
 .../2025-11-03/1/include/Decision.hpp         | 266 +++++++++++
 .../2025-11-03/1/include/Dynamics.hpp         | 214 +++++++++
 .../2025-11-03/1/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-11-03/1/include/IO.hpp  | 150 +++++++
 .../2025-11-03/1/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-11-03/1/include/Queue.hpp |  70 +++
 .../2025-11-03/1/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-11-03/1/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-11-03/1/main            | Bin 0 -> 43848 bytes
 exams/AxelRubini/2025-11-03/1/main.cpp        |  39 ++
 exams/AxelRubini/2025-11-03/1/parameters.txt  |  18 +
 exams/AxelRubini/2025-11-03/1/results.txt     |   2 +
 exams/AxelRubini/2025-11-03/2/Makefile        |  10 +
 exams/AxelRubini/2025-11-03/2/include/DES.hpp | 212 +++++++++
 .../2025-11-03/2/include/Decision.hpp         | 266 +++++++++++
 .../2025-11-03/2/include/Dynamics.hpp         | 214 +++++++++
 .../2025-11-03/2/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-11-03/2/include/IO.hpp  | 150 +++++++
 .../2025-11-03/2/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-11-03/2/include/Queue.hpp |  70 +++
 .../2025-11-03/2/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-11-03/2/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-11-03/2/main            | Bin 0 -> 44016 bytes
 exams/AxelRubini/2025-11-03/2/main.cpp        |  42 ++
 exams/AxelRubini/2025-11-03/2/parameters.txt  |  18 +
 exams/AxelRubini/2025-11-03/2/results.txt     |   2 +
 exams/AxelRubini/2025-11-03/3/Makefile        |  10 +
 exams/AxelRubini/2025-11-03/3/include/DES.hpp | 212 +++++++++
 .../2025-11-03/3/include/Decision.hpp         | 266 +++++++++++
 .../2025-11-03/3/include/Dynamics.hpp         | 214 +++++++++
 .../2025-11-03/3/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-11-03/3/include/IO.hpp  | 150 +++++++
 .../2025-11-03/3/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-11-03/3/include/Queue.hpp |  70 +++
 .../2025-11-03/3/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-11-03/3/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-11-03/3/main            | Bin 0 -> 52528 bytes
 exams/AxelRubini/2025-11-03/3/main.cpp        |  72 +++
 exams/AxelRubini/2025-11-03/3/parameters.txt  |  19 +
 exams/AxelRubini/2025-11-03/3/results.txt     |   4 +
 exams/AxelRubini/2025-11-03/4/include/DES.hpp | 212 +++++++++
 .../2025-11-03/4/include/Decision.hpp         | 266 +++++++++++
 .../2025-11-03/4/include/Dynamics.hpp         | 214 +++++++++
 .../2025-11-03/4/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-11-03/4/include/IO.hpp  | 150 +++++++
 .../2025-11-03/4/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-11-03/4/include/Queue.hpp |  70 +++
 .../2025-11-03/4/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-11-03/4/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-11-03/4/main            | Bin 0 -> 57600 bytes
 exams/AxelRubini/2025-11-03/4/main.cpp        | 117 +++++
 exams/AxelRubini/2025-11-03/4/parameters.txt  |  10 +
 exams/AxelRubini/2025-11-03/4/results.txt     |   2 +
 exams/AxelRubini/2025-11-03/5/include/DES.hpp | 212 +++++++++
 .../2025-11-03/5/include/Decision.hpp         | 266 +++++++++++
 .../2025-11-03/5/include/Dynamics.hpp         | 214 +++++++++
 .../2025-11-03/5/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2025-11-03/5/include/IO.hpp  | 150 +++++++
 .../2025-11-03/5/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2025-11-03/5/include/Queue.hpp |  70 +++
 .../2025-11-03/5/include/Random.hpp           |  77 ++++
 .../AxelRubini/2025-11-03/5/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2025-11-03/5/main            | Bin 0 -> 57760 bytes
 exams/AxelRubini/2025-11-03/5/main.cpp        | 137 ++++++
 exams/AxelRubini/2025-11-03/5/parameters.txt  |  11 +
 exams/AxelRubini/2025-11-03/5/results.txt     |   4 +
 exams/AxelRubini/2026-01-14/1/Makefile        |  10 +
 exams/AxelRubini/2026-01-14/1/include/DES.hpp | 212 +++++++++
 .../2026-01-14/1/include/Decision.hpp         | 266 +++++++++++
 .../2026-01-14/1/include/Dynamics.hpp         | 214 +++++++++
 .../2026-01-14/1/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2026-01-14/1/include/IO.hpp  | 150 +++++++
 .../2026-01-14/1/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2026-01-14/1/include/Queue.hpp |  70 +++
 .../2026-01-14/1/include/Random.hpp           |  77 ++++
 .../AxelRubini/2026-01-14/1/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2026-01-14/1/main            | Bin 0 -> 43952 bytes
 exams/AxelRubini/2026-01-14/1/main.cpp        |  89 ++++
 exams/AxelRubini/2026-01-14/1/parameters.txt  |   9 +
 exams/AxelRubini/2026-01-14/1/results.txt     |   2 +
 exams/AxelRubini/2026-01-14/2/Makefile        |  10 +
 exams/AxelRubini/2026-01-14/2/include/DES.hpp | 212 +++++++++
 .../2026-01-14/2/include/Decision.hpp         | 266 +++++++++++
 .../2026-01-14/2/include/Dynamics.hpp         | 214 +++++++++
 .../2026-01-14/2/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2026-01-14/2/include/IO.hpp  | 150 +++++++
 .../2026-01-14/2/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2026-01-14/2/include/Queue.hpp |  70 +++
 .../2026-01-14/2/include/Random.hpp           |  77 ++++
 .../AxelRubini/2026-01-14/2/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2026-01-14/2/main            | Bin 0 -> 43768 bytes
 exams/AxelRubini/2026-01-14/2/main.cpp        | 109 +++++
 exams/AxelRubini/2026-01-14/2/parameters.txt  |   9 +
 exams/AxelRubini/2026-01-14/2/results.txt     |   2 +
 exams/AxelRubini/2026-01-14/3/Makefile        |  10 +
 exams/AxelRubini/2026-01-14/3/include/DES.hpp | 212 +++++++++
 .../2026-01-14/3/include/Decision.hpp         | 266 +++++++++++
 .../2026-01-14/3/include/Dynamics.hpp         | 214 +++++++++
 .../2026-01-14/3/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2026-01-14/3/include/IO.hpp  | 150 +++++++
 .../2026-01-14/3/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2026-01-14/3/include/Queue.hpp |  70 +++
 .../2026-01-14/3/include/Random.hpp           |  77 ++++
 .../AxelRubini/2026-01-14/3/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2026-01-14/3/main            | Bin 0 -> 81552 bytes
 exams/AxelRubini/2026-01-14/3/main.cpp        | 174 +++++++
 exams/AxelRubini/2026-01-14/3/out.log         |   0
 exams/AxelRubini/2026-01-14/3/parameters.txt  |  14 +
 exams/AxelRubini/2026-01-14/3/results.txt     |   2 +
 exams/AxelRubini/2026-01-14/4/Makefile        |  10 +
 exams/AxelRubini/2026-01-14/4/include/DES.hpp | 212 +++++++++
 .../2026-01-14/4/include/Decision.hpp         | 266 +++++++++++
 .../2026-01-14/4/include/Dynamics.hpp         | 214 +++++++++
 .../2026-01-14/4/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2026-01-14/4/include/IO.hpp  | 150 +++++++
 .../2026-01-14/4/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2026-01-14/4/include/Queue.hpp |  70 +++
 .../2026-01-14/4/include/Random.hpp           |  77 ++++
 .../AxelRubini/2026-01-14/4/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2026-01-14/4/main            | Bin 0 -> 81768 bytes
 exams/AxelRubini/2026-01-14/4/main.cpp        | 202 +++++++++
 exams/AxelRubini/2026-01-14/4/parameters.txt  |  17 +
 exams/AxelRubini/2026-01-14/4/results.txt     |   4 +
 exams/AxelRubini/2026-01-14/5/Makefile        |  10 +
 exams/AxelRubini/2026-01-14/5/include/DES.hpp | 212 +++++++++
 .../2026-01-14/5/include/Decision.hpp         | 266 +++++++++++
 .../2026-01-14/5/include/Dynamics.hpp         | 214 +++++++++
 .../2026-01-14/5/include/Geometry.hpp         | 111 +++++
 exams/AxelRubini/2026-01-14/5/include/IO.hpp  | 150 +++++++
 .../2026-01-14/5/include/Inventory.hpp        | 423 ++++++++++++++++++
 .../AxelRubini/2026-01-14/5/include/Queue.hpp |  70 +++
 .../2026-01-14/5/include/Random.hpp           |  77 ++++
 .../AxelRubini/2026-01-14/5/include/Stat.hpp  |  72 +++
 exams/AxelRubini/2026-01-14/5/main            | Bin 0 -> 81712 bytes
 exams/AxelRubini/2026-01-14/5/main.cpp        | 110 +++++
 exams/AxelRubini/2026-01-14/5/parameters.txt  |  17 +
 exams/AxelRubini/2026-01-14/5/results.txt     |   5 +
 559 files changed, 69466 insertions(+)
 create mode 100644 exams/AxelRubini/2025-01-09/1/Makefile
 create mode 100644 exams/AxelRubini/2025-01-09/1/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/1/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/1/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/1/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/1/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/1/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/1/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/1/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/1/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-01-09/1/main
 create mode 100644 exams/AxelRubini/2025-01-09/1/main.cpp
 create mode 100644 exams/AxelRubini/2025-01-09/1/parameters.txt
 create mode 100644 exams/AxelRubini/2025-01-09/1/results.txt
 create mode 100644 exams/AxelRubini/2025-01-09/2/Makefile
 create mode 100644 exams/AxelRubini/2025-01-09/2/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/2/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/2/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/2/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/2/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/2/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/2/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/2/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/2/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-01-09/2/main
 create mode 100644 exams/AxelRubini/2025-01-09/2/main.cpp
 create mode 100644 exams/AxelRubini/2025-01-09/2/parameters.txt
 create mode 100644 exams/AxelRubini/2025-01-09/2/results.txt
 create mode 100644 exams/AxelRubini/2025-01-09/3/Makefile
 create mode 100644 exams/AxelRubini/2025-01-09/3/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/3/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/3/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/3/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/3/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/3/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/3/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/3/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/3/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-01-09/3/main
 create mode 100644 exams/AxelRubini/2025-01-09/3/main.cpp
 create mode 100644 exams/AxelRubini/2025-01-09/3/parameters.txt
 create mode 100644 exams/AxelRubini/2025-01-09/3/results.txt
 create mode 100644 exams/AxelRubini/2025-01-09/4/Makefile
 create mode 100644 exams/AxelRubini/2025-01-09/4/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/4/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/4/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/4/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/4/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/4/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/4/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/4/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/4/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-01-09/4/main
 create mode 100644 exams/AxelRubini/2025-01-09/4/main.cpp
 create mode 100644 exams/AxelRubini/2025-01-09/4/parameters.txt
 create mode 100644 exams/AxelRubini/2025-01-09/4/results.txt
 create mode 100644 exams/AxelRubini/2025-01-09/5/Makefile
 create mode 100644 exams/AxelRubini/2025-01-09/5/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/5/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/5/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/5/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/5/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/5/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/5/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/5/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-01-09/5/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-01-09/5/main
 create mode 100644 exams/AxelRubini/2025-01-09/5/main.cpp
 create mode 100644 exams/AxelRubini/2025-01-09/5/parameters.txt
 create mode 100644 exams/AxelRubini/2025-01-09/5/results.txt
 create mode 100644 exams/AxelRubini/2025-02-05/1/Makefile
 create mode 100644 exams/AxelRubini/2025-02-05/1/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/1/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/1/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/1/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/1/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/1/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/1/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/1/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/1/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-02-05/1/main
 create mode 100644 exams/AxelRubini/2025-02-05/1/main.cpp
 create mode 100644 exams/AxelRubini/2025-02-05/1/parameters.txt
 create mode 100644 exams/AxelRubini/2025-02-05/1/results.txt
 create mode 100644 exams/AxelRubini/2025-02-05/2/Makefile
 create mode 100644 exams/AxelRubini/2025-02-05/2/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/2/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/2/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/2/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/2/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/2/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/2/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/2/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/2/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-02-05/2/main
 create mode 100644 exams/AxelRubini/2025-02-05/2/main.cpp
 create mode 100644 exams/AxelRubini/2025-02-05/2/parameters.txt
 create mode 100644 exams/AxelRubini/2025-02-05/2/results.txt
 create mode 100644 exams/AxelRubini/2025-02-05/3/Makefile
 create mode 100644 exams/AxelRubini/2025-02-05/3/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/3/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/3/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/3/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/3/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/3/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/3/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/3/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/3/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-02-05/3/main
 create mode 100644 exams/AxelRubini/2025-02-05/3/main.cpp
 create mode 100644 exams/AxelRubini/2025-02-05/3/parameters.txt
 create mode 100644 exams/AxelRubini/2025-02-05/3/results.txt
 create mode 100644 exams/AxelRubini/2025-02-05/4/Makefile
 create mode 100644 exams/AxelRubini/2025-02-05/4/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/4/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/4/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/4/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/4/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/4/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/4/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/4/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/4/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-02-05/4/main
 create mode 100644 exams/AxelRubini/2025-02-05/4/main.cpp
 create mode 100644 exams/AxelRubini/2025-02-05/4/parameters.txt
 create mode 100644 exams/AxelRubini/2025-02-05/4/results.txt
 create mode 100644 exams/AxelRubini/2025-02-05/5/Makefile
 create mode 100644 exams/AxelRubini/2025-02-05/5/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/5/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/5/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/5/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/5/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/5/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/5/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/5/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-02-05/5/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-02-05/5/main
 create mode 100644 exams/AxelRubini/2025-02-05/5/main.cpp
 create mode 100644 exams/AxelRubini/2025-02-05/5/parameters.txt
 create mode 100644 exams/AxelRubini/2025-02-05/5/results.txt
 create mode 100644 exams/AxelRubini/2025-03-21/1/Makefile
 create mode 100644 exams/AxelRubini/2025-03-21/1/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/1/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/1/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/1/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/1/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/1/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/1/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/1/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/1/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-03-21/1/main
 create mode 100644 exams/AxelRubini/2025-03-21/1/main.cpp
 create mode 100644 exams/AxelRubini/2025-03-21/1/parameters.txt
 create mode 100644 exams/AxelRubini/2025-03-21/1/results.txt
 create mode 100644 exams/AxelRubini/2025-03-21/2/Makefile
 create mode 100644 exams/AxelRubini/2025-03-21/2/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/2/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/2/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/2/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/2/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/2/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/2/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/2/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/2/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-03-21/2/main
 create mode 100644 exams/AxelRubini/2025-03-21/2/main.cpp
 create mode 100644 exams/AxelRubini/2025-03-21/2/parameters.txt
 create mode 100644 exams/AxelRubini/2025-03-21/2/results.txt
 create mode 100644 exams/AxelRubini/2025-03-21/3/Makefile
 create mode 100644 exams/AxelRubini/2025-03-21/3/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/3/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/3/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/3/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/3/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/3/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/3/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/3/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/3/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-03-21/3/main
 create mode 100644 exams/AxelRubini/2025-03-21/3/main.cpp
 create mode 100644 exams/AxelRubini/2025-03-21/3/parameters.txt
 create mode 100644 exams/AxelRubini/2025-03-21/3/results.txt
 create mode 100644 exams/AxelRubini/2025-03-21/4/Makefile
 create mode 100644 exams/AxelRubini/2025-03-21/4/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/4/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/4/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/4/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/4/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/4/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/4/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/4/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/4/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-03-21/4/main
 create mode 100644 exams/AxelRubini/2025-03-21/4/main.cpp
 create mode 100644 exams/AxelRubini/2025-03-21/4/parameters.txt
 create mode 100644 exams/AxelRubini/2025-03-21/4/results.txt
 create mode 100644 exams/AxelRubini/2025-03-21/5/Makefile
 create mode 100644 exams/AxelRubini/2025-03-21/5/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/5/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/5/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/5/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/5/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/5/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/5/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/5/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-03-21/5/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-03-21/5/main
 create mode 100644 exams/AxelRubini/2025-03-21/5/main.cpp
 create mode 100644 exams/AxelRubini/2025-03-21/5/parameters.txt
 create mode 100644 exams/AxelRubini/2025-03-21/5/results.txt
 create mode 100644 exams/AxelRubini/2025-06-12/1/Makefile
 create mode 100644 exams/AxelRubini/2025-06-12/1/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/1/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/1/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/1/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/1/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/1/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/1/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/1/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/1/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-06-12/1/main
 create mode 100644 exams/AxelRubini/2025-06-12/1/main.cpp
 create mode 100644 exams/AxelRubini/2025-06-12/1/parameters.txt
 create mode 100644 exams/AxelRubini/2025-06-12/1/results.txt
 create mode 100644 exams/AxelRubini/2025-06-12/2/Makefile
 create mode 100644 exams/AxelRubini/2025-06-12/2/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/2/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/2/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/2/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/2/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/2/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/2/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/2/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/2/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-06-12/2/main
 create mode 100644 exams/AxelRubini/2025-06-12/2/main.cpp
 create mode 100644 exams/AxelRubini/2025-06-12/2/parameters.txt
 create mode 100644 exams/AxelRubini/2025-06-12/2/results.txt
 create mode 100644 exams/AxelRubini/2025-06-12/3/Makefile
 create mode 100644 exams/AxelRubini/2025-06-12/3/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/3/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/3/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/3/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/3/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/3/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/3/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/3/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/3/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-06-12/3/main
 create mode 100644 exams/AxelRubini/2025-06-12/3/main.cpp
 create mode 100644 exams/AxelRubini/2025-06-12/3/parameters.txt
 create mode 100644 exams/AxelRubini/2025-06-12/3/results.txt
 create mode 100644 exams/AxelRubini/2025-06-12/4/Makefile
 create mode 100644 exams/AxelRubini/2025-06-12/4/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/4/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/4/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/4/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/4/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/4/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/4/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/4/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/4/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-06-12/4/main
 create mode 100644 exams/AxelRubini/2025-06-12/4/main.cpp
 create mode 100644 exams/AxelRubini/2025-06-12/4/parameters.txt
 create mode 100644 exams/AxelRubini/2025-06-12/4/results.txt
 create mode 100644 exams/AxelRubini/2025-06-12/5/Makefile
 create mode 100644 exams/AxelRubini/2025-06-12/5/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/5/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/5/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/5/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/5/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/5/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/5/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/5/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-06-12/5/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-06-12/5/main
 create mode 100644 exams/AxelRubini/2025-06-12/5/main.cpp
 create mode 100644 exams/AxelRubini/2025-06-12/5/parameters.txt
 create mode 100644 exams/AxelRubini/2025-06-12/5/results.txt
 create mode 100644 exams/AxelRubini/2025-07-08/1/Makefile
 create mode 100644 exams/AxelRubini/2025-07-08/1/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/1/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/1/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/1/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/1/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/1/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/1/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/1/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/1/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-07-08/1/main
 create mode 100644 exams/AxelRubini/2025-07-08/1/main.cpp
 create mode 100644 exams/AxelRubini/2025-07-08/1/parameters.txt
 create mode 100644 exams/AxelRubini/2025-07-08/1/results.txt
 create mode 100644 exams/AxelRubini/2025-07-08/2/Makefile
 create mode 100644 exams/AxelRubini/2025-07-08/2/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/2/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/2/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/2/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/2/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/2/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/2/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/2/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/2/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-07-08/2/main
 create mode 100644 exams/AxelRubini/2025-07-08/2/main.cpp
 create mode 100644 exams/AxelRubini/2025-07-08/2/parameters.txt
 create mode 100644 exams/AxelRubini/2025-07-08/2/results.txt
 create mode 100644 exams/AxelRubini/2025-07-08/3/Makefile
 create mode 100644 exams/AxelRubini/2025-07-08/3/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/3/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/3/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/3/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/3/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/3/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/3/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/3/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/3/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-07-08/3/main
 create mode 100644 exams/AxelRubini/2025-07-08/3/main.cpp
 create mode 100644 exams/AxelRubini/2025-07-08/3/parameters.txt
 create mode 100644 exams/AxelRubini/2025-07-08/3/results.txt
 create mode 100644 exams/AxelRubini/2025-07-08/4/Makefile
 create mode 100644 exams/AxelRubini/2025-07-08/4/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/4/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/4/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/4/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/4/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/4/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/4/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/4/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/4/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-07-08/4/main
 create mode 100644 exams/AxelRubini/2025-07-08/4/main.cpp
 create mode 100644 exams/AxelRubini/2025-07-08/4/parameters.txt
 create mode 100644 exams/AxelRubini/2025-07-08/4/results.txt
 create mode 100644 exams/AxelRubini/2025-07-08/5/Makefile
 create mode 100644 exams/AxelRubini/2025-07-08/5/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/5/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/5/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/5/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/5/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/5/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/5/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/5/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-07-08/5/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-07-08/5/main
 create mode 100644 exams/AxelRubini/2025-07-08/5/main.cpp
 create mode 100644 exams/AxelRubini/2025-07-08/5/parameters.txt
 create mode 100644 exams/AxelRubini/2025-07-08/5/results.txt
 create mode 100644 exams/AxelRubini/2025-09-08/1/Makefile
 create mode 100644 exams/AxelRubini/2025-09-08/1/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/1/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/1/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/1/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/1/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/1/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/1/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/1/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/1/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-09-08/1/main
 create mode 100644 exams/AxelRubini/2025-09-08/1/main.cpp
 create mode 100644 exams/AxelRubini/2025-09-08/1/parameters.txt
 create mode 100644 exams/AxelRubini/2025-09-08/1/results.txt
 create mode 100644 exams/AxelRubini/2025-09-08/2/Makefile
 create mode 100644 exams/AxelRubini/2025-09-08/2/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/2/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/2/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/2/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/2/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/2/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/2/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/2/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/2/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-09-08/2/main
 create mode 100644 exams/AxelRubini/2025-09-08/2/main.cpp
 create mode 100644 exams/AxelRubini/2025-09-08/2/parameters.txt
 create mode 100644 exams/AxelRubini/2025-09-08/2/results.txt
 create mode 100644 exams/AxelRubini/2025-09-08/3/Makefile
 create mode 100644 exams/AxelRubini/2025-09-08/3/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/3/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/3/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/3/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/3/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/3/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/3/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/3/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/3/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-09-08/3/main
 create mode 100644 exams/AxelRubini/2025-09-08/3/main.cpp
 create mode 100644 exams/AxelRubini/2025-09-08/3/parameters.txt
 create mode 100644 exams/AxelRubini/2025-09-08/3/results.txt
 create mode 100644 exams/AxelRubini/2025-09-08/4/Makefile
 create mode 100644 exams/AxelRubini/2025-09-08/4/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/4/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/4/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/4/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/4/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/4/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/4/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/4/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/4/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-09-08/4/main
 create mode 100644 exams/AxelRubini/2025-09-08/4/main.cpp
 create mode 100644 exams/AxelRubini/2025-09-08/4/parameters.txt
 create mode 100644 exams/AxelRubini/2025-09-08/4/results.txt
 create mode 100644 exams/AxelRubini/2025-09-08/5/Makefile
 create mode 100644 exams/AxelRubini/2025-09-08/5/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/5/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/5/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/5/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/5/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/5/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/5/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/5/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-09-08/5/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-09-08/5/main
 create mode 100644 exams/AxelRubini/2025-09-08/5/main.cpp
 create mode 100644 exams/AxelRubini/2025-09-08/5/parameters.txt
 create mode 100644 exams/AxelRubini/2025-09-08/5/results.txt
 create mode 100644 exams/AxelRubini/2025-11-03/1/Makefile
 create mode 100644 exams/AxelRubini/2025-11-03/1/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/1/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/1/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/1/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/1/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/1/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/1/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/1/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/1/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-11-03/1/main
 create mode 100644 exams/AxelRubini/2025-11-03/1/main.cpp
 create mode 100644 exams/AxelRubini/2025-11-03/1/parameters.txt
 create mode 100644 exams/AxelRubini/2025-11-03/1/results.txt
 create mode 100644 exams/AxelRubini/2025-11-03/2/Makefile
 create mode 100644 exams/AxelRubini/2025-11-03/2/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/2/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/2/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/2/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/2/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/2/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/2/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/2/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/2/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-11-03/2/main
 create mode 100644 exams/AxelRubini/2025-11-03/2/main.cpp
 create mode 100644 exams/AxelRubini/2025-11-03/2/parameters.txt
 create mode 100644 exams/AxelRubini/2025-11-03/2/results.txt
 create mode 100644 exams/AxelRubini/2025-11-03/3/Makefile
 create mode 100644 exams/AxelRubini/2025-11-03/3/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/3/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/3/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/3/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/3/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/3/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/3/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/3/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/3/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-11-03/3/main
 create mode 100644 exams/AxelRubini/2025-11-03/3/main.cpp
 create mode 100644 exams/AxelRubini/2025-11-03/3/parameters.txt
 create mode 100644 exams/AxelRubini/2025-11-03/3/results.txt
 create mode 100644 exams/AxelRubini/2025-11-03/4/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/4/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/4/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/4/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/4/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/4/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/4/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/4/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/4/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-11-03/4/main
 create mode 100644 exams/AxelRubini/2025-11-03/4/main.cpp
 create mode 100644 exams/AxelRubini/2025-11-03/4/parameters.txt
 create mode 100644 exams/AxelRubini/2025-11-03/4/results.txt
 create mode 100644 exams/AxelRubini/2025-11-03/5/include/DES.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/5/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/5/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/5/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/5/include/IO.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/5/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/5/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/5/include/Random.hpp
 create mode 100644 exams/AxelRubini/2025-11-03/5/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2025-11-03/5/main
 create mode 100644 exams/AxelRubini/2025-11-03/5/main.cpp
 create mode 100644 exams/AxelRubini/2025-11-03/5/parameters.txt
 create mode 100644 exams/AxelRubini/2025-11-03/5/results.txt
 create mode 100644 exams/AxelRubini/2026-01-14/1/Makefile
 create mode 100644 exams/AxelRubini/2026-01-14/1/include/DES.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/1/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/1/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/1/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/1/include/IO.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/1/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/1/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/1/include/Random.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/1/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2026-01-14/1/main
 create mode 100644 exams/AxelRubini/2026-01-14/1/main.cpp
 create mode 100644 exams/AxelRubini/2026-01-14/1/parameters.txt
 create mode 100644 exams/AxelRubini/2026-01-14/1/results.txt
 create mode 100644 exams/AxelRubini/2026-01-14/2/Makefile
 create mode 100644 exams/AxelRubini/2026-01-14/2/include/DES.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/2/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/2/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/2/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/2/include/IO.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/2/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/2/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/2/include/Random.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/2/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2026-01-14/2/main
 create mode 100644 exams/AxelRubini/2026-01-14/2/main.cpp
 create mode 100644 exams/AxelRubini/2026-01-14/2/parameters.txt
 create mode 100644 exams/AxelRubini/2026-01-14/2/results.txt
 create mode 100644 exams/AxelRubini/2026-01-14/3/Makefile
 create mode 100644 exams/AxelRubini/2026-01-14/3/include/DES.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/3/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/3/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/3/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/3/include/IO.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/3/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/3/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/3/include/Random.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/3/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2026-01-14/3/main
 create mode 100644 exams/AxelRubini/2026-01-14/3/main.cpp
 create mode 100644 exams/AxelRubini/2026-01-14/3/out.log
 create mode 100644 exams/AxelRubini/2026-01-14/3/parameters.txt
 create mode 100644 exams/AxelRubini/2026-01-14/3/results.txt
 create mode 100644 exams/AxelRubini/2026-01-14/4/Makefile
 create mode 100644 exams/AxelRubini/2026-01-14/4/include/DES.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/4/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/4/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/4/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/4/include/IO.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/4/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/4/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/4/include/Random.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/4/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2026-01-14/4/main
 create mode 100644 exams/AxelRubini/2026-01-14/4/main.cpp
 create mode 100644 exams/AxelRubini/2026-01-14/4/parameters.txt
 create mode 100644 exams/AxelRubini/2026-01-14/4/results.txt
 create mode 100644 exams/AxelRubini/2026-01-14/5/Makefile
 create mode 100644 exams/AxelRubini/2026-01-14/5/include/DES.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/5/include/Decision.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/5/include/Dynamics.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/5/include/Geometry.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/5/include/IO.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/5/include/Inventory.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/5/include/Queue.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/5/include/Random.hpp
 create mode 100644 exams/AxelRubini/2026-01-14/5/include/Stat.hpp
 create mode 100755 exams/AxelRubini/2026-01-14/5/main
 create mode 100644 exams/AxelRubini/2026-01-14/5/main.cpp
 create mode 100644 exams/AxelRubini/2026-01-14/5/parameters.txt
 create mode 100644 exams/AxelRubini/2026-01-14/5/results.txt

diff --git a/exams/AxelRubini/2025-01-09/1/Makefile b/exams/AxelRubini/2025-01-09/1/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-01-09/1/include/DES.hpp b/exams/AxelRubini/2025-01-09/1/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/1/include/Decision.hpp b/exams/AxelRubini/2025-01-09/1/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/1/include/Dynamics.hpp b/exams/AxelRubini/2025-01-09/1/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/1/include/Geometry.hpp b/exams/AxelRubini/2025-01-09/1/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/1/include/IO.hpp b/exams/AxelRubini/2025-01-09/1/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/1/include/Inventory.hpp b/exams/AxelRubini/2025-01-09/1/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/1/include/Queue.hpp b/exams/AxelRubini/2025-01-09/1/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/1/include/Random.hpp b/exams/AxelRubini/2025-01-09/1/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/1/include/Stat.hpp b/exams/AxelRubini/2025-01-09/1/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/1/main b/exams/AxelRubini/2025-01-09/1/main
new file mode 100755
index 0000000000000000000000000000000000000000..ac457245bd8e39b756d260c3daf28696801211d6
GIT binary patch
literal 44208
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
E1HB7&VgLXD

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-01-09/1/main.cpp b/exams/AxelRubini/2025-01-09/1/main.cpp
new file mode 100644
index 0000000..a8c4fb4
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/main.cpp
@@ -0,0 +1,42 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+int main() {
+    SELib::RandomGenerator rng;
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt")) {
+        return 1;
+    }
+
+    int numStates = parser.getInt("N", 0);
+    if (numStates <= 0)
+        return 1;
+
+    SELib::MDP mdp(numStates, rng);
+    const auto &data = parser.getStructuredData();
+    for (const auto &line : data) {
+        if (!line.empty() && line[0] == "A") {
+            int from = std::stoi(line[1]);
+            int to = std::stoi(line[2]);
+            double prob = std::stod(line[3]);
+            double cost = std::stod(line[4]);
+            mdp.addTransition(from, to, prob, cost);
+        }
+    }
+
+    SELib::MonteCarloSimulator simulator(1000);
+    double expectedCost =
+        simulator.estimate([&](int) { return mdp.simulate(0, numStates - 1); });
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-01-09-Axel-Rubini-2158099" << std::endl;
+    outFile << "C " << expectedCost << std::endl;
+    outFile.close();
+
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-01-09/1/parameters.txt b/exams/AxelRubini/2025-01-09/1/parameters.txt
new file mode 100644
index 0000000..7f56793
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/parameters.txt
@@ -0,0 +1,11 @@
+N 5
+A 0 1 1 100
+A 1 2 0.3 100
+A 1 3 0.7 150
+A 2 3 1 100
+A 3 0 0.6 10
+A 3 1 0.1 10
+A 3 2 0.1 10
+A 3 3 0.1 10
+A 3 4 0.1 10
+A 4 4 1 0
diff --git a/exams/AxelRubini/2025-01-09/1/results.txt b/exams/AxelRubini/2025-01-09/1/results.txt
new file mode 100644
index 0000000..4ddcdff
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/1/results.txt
@@ -0,0 +1,2 @@
+2025-01-09-Axel-Rubini-2158099
+C 2333.51
diff --git a/exams/AxelRubini/2025-01-09/2/Makefile b/exams/AxelRubini/2025-01-09/2/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-01-09/2/include/DES.hpp b/exams/AxelRubini/2025-01-09/2/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/2/include/Decision.hpp b/exams/AxelRubini/2025-01-09/2/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/2/include/Dynamics.hpp b/exams/AxelRubini/2025-01-09/2/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/2/include/Geometry.hpp b/exams/AxelRubini/2025-01-09/2/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/2/include/IO.hpp b/exams/AxelRubini/2025-01-09/2/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/2/include/Inventory.hpp b/exams/AxelRubini/2025-01-09/2/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/2/include/Queue.hpp b/exams/AxelRubini/2025-01-09/2/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/2/include/Random.hpp b/exams/AxelRubini/2025-01-09/2/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/2/include/Stat.hpp b/exams/AxelRubini/2025-01-09/2/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/2/main b/exams/AxelRubini/2025-01-09/2/main
new file mode 100755
index 0000000000000000000000000000000000000000..5d928a6e7ff834a12972a177abe9942df812c0d9
GIT binary patch
literal 44376
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
Nxrs47p+G`X`QOC!0A~OI

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-01-09/2/main.cpp b/exams/AxelRubini/2025-01-09/2/main.cpp
new file mode 100644
index 0000000..a9953f3
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/main.cpp
@@ -0,0 +1,44 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+int main() {
+    SELib::RandomGenerator rng;
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt")) {
+        return 1;
+    }
+
+    double maxCost = parser.getDouble("C", 0.0);
+    int numStates = parser.getInt("N", 0);
+    if (numStates <= 0)
+        return 1;
+
+    SELib::MDP mdp(numStates, rng);
+    const auto &data = parser.getStructuredData();
+    for (const auto &line : data) {
+        if (!line.empty() && line[0] == "A") {
+            int from = std::stoi(line[1]);
+            int to = std::stoi(line[2]);
+            double prob = std::stod(line[3]);
+            double cost = std::stod(line[4]);
+            mdp.addTransition(from, to, prob, cost);
+        }
+    }
+
+    SELib::MonteCarloSimulator simulator(1000);
+    double prob = simulator.estimateProbability([&](int) {
+        return mdp.simulate(0, numStates - 1) <= maxCost;
+    });
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-01-09-Axel-Rubini-2158099" << std::endl;
+    outFile << "P " << prob << std::endl;
+    outFile.close();
+
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-01-09/2/parameters.txt b/exams/AxelRubini/2025-01-09/2/parameters.txt
new file mode 100644
index 0000000..541d237
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/parameters.txt
@@ -0,0 +1,12 @@
+C 200
+N 5
+A 0 1 0.7 100
+A 0 2 0.3 50
+A 1 3 1.0 100
+A 2 3 1.0 100
+A 3 3 1.0 70
+A 4 0 0.2 5
+A 4 1 0.2 10
+A 4 2 0.2 20
+A 4 3 0.2 30
+A 4 4 0.2 40
diff --git a/exams/AxelRubini/2025-01-09/2/results.txt b/exams/AxelRubini/2025-01-09/2/results.txt
new file mode 100644
index 0000000..f185dcc
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/2/results.txt
@@ -0,0 +1,2 @@
+2025-01-09-Axel-Rubini-2158099
+P 0
diff --git a/exams/AxelRubini/2025-01-09/3/Makefile b/exams/AxelRubini/2025-01-09/3/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-01-09/3/include/DES.hpp b/exams/AxelRubini/2025-01-09/3/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/3/include/Decision.hpp b/exams/AxelRubini/2025-01-09/3/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/3/include/Dynamics.hpp b/exams/AxelRubini/2025-01-09/3/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/3/include/Geometry.hpp b/exams/AxelRubini/2025-01-09/3/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/3/include/IO.hpp b/exams/AxelRubini/2025-01-09/3/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/3/include/Inventory.hpp b/exams/AxelRubini/2025-01-09/3/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/3/include/Queue.hpp b/exams/AxelRubini/2025-01-09/3/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/3/include/Random.hpp b/exams/AxelRubini/2025-01-09/3/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/3/include/Stat.hpp b/exams/AxelRubini/2025-01-09/3/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/3/main b/exams/AxelRubini/2025-01-09/3/main
new file mode 100755
index 0000000000000000000000000000000000000000..7dd71d7f17932a858fb85c77cb82f7487bf99060
GIT binary patch
literal 73624
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-01-09/3/main.cpp b/exams/AxelRubini/2025-01-09/3/main.cpp
new file mode 100644
index 0000000..5f96206
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/main.cpp
@@ -0,0 +1,133 @@
+#include "include/DES.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include "include/Stat.hpp"
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+class EcommerceCustomer : public DiscreteEventProcess {
+  public:
+    EcommerceCustomer(
+        int pid,
+        MessageBus &bus,
+        RandomGenerator &rng,
+        double avg,
+        double stddev
+    )
+        : pid_(pid), bus_(bus), rng_(rng), avg_(avg), stddev_(stddev) {}
+
+    void initialize(double startTime) override { scheduleNext(startTime); }
+
+    double nextEventTime() const override { return nextEventTime_; }
+
+    void handleEvent(double currentTime) override {
+        Message msg;
+        msg.time = currentTime;
+        msg.sender = pid_;
+        msg.receiver = 1; // Monitor PID
+        bus_.procToNet(pid_).push(msg);
+
+        scheduleNext(currentTime);
+    }
+
+  private:
+    void scheduleNext(double currentTime) {
+        // T soggiorno in idle ~ Gaussiana(Avg, StdDev)
+        double delay = rng_.gaussian(avg_, stddev_);
+        if (delay < 1.0)
+            delay = 1.0; // Time step minimo T=1
+        nextEventTime_ = currentTime + delay;
+    }
+
+    int pid_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+    double avg_;
+    double stddev_;
+    double nextEventTime_;
+};
+
+class EcommerceMonitor : public DiscreteEventProcess {
+  public:
+    EcommerceMonitor(int pid, MessageBus &bus)
+        : pid_(pid), bus_(bus), lastRequestTime_(-1.0) {}
+
+    void initialize(double startTime) override {}
+
+    double nextEventTime() const override {
+        return std::numeric_limits<double>::infinity();
+    }
+
+    void handleEvent(double currentTime) override {}
+
+    void processInbox() {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            Message m = inbox.front();
+            inbox.pop();
+
+            if (lastRequestTime_ >= 0) {
+                stats_.addSample(m.time - lastRequestTime_);
+            }
+            lastRequestTime_ = m.time;
+        }
+    }
+
+    double getAvg() const { return stats_.mean(); }
+    double getStdDev() const { return stats_.stddev(); }
+
+  private:
+    int pid_;
+    MessageBus &bus_;
+    double lastRequestTime_;
+    Statistics stats_;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng;
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt")) {
+        return 1;
+    }
+
+    double avg = parser.getDouble("Avg", 3600.0);
+    double stddev = parser.getDouble("StdDev", 500.0);
+
+    SELib::MessageBus bus(2);
+    SELib::DiscreteEventSystem system;
+
+    // Processo 0: Customer
+    system.emplaceProcess<SELib::EcommerceCustomer>(0, bus, rng, avg, stddev);
+    // Processo 1: Monitor
+    auto &monitor = system.emplaceProcess<SELib::EcommerceMonitor>(1, bus);
+    // Network Router
+    system.emplaceProcess<SELib::NetworkRouter>(bus, rng, 0.1);
+
+    double currentTime = 0.0;
+    double horizon = 1000000.0;
+    system.initialize(0.0);
+
+    while (currentTime < horizon) {
+        double nextTime = system.nextEventTime();
+        if (nextTime > horizon)
+            break;
+        currentTime = nextTime;
+        system.handleEvent(currentTime);
+        monitor.processInbox();
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-01-09-Axel-Rubini-2158099" << std::endl;
+    outFile << "Avg " << monitor.getAvg() << std::endl;
+    outFile << "StdDev " << monitor.getStdDev() << std::endl;
+    outFile.close();
+
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-01-09/3/parameters.txt b/exams/AxelRubini/2025-01-09/3/parameters.txt
new file mode 100644
index 0000000..5b5ab4e
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/parameters.txt
@@ -0,0 +1,2 @@
+Avg 100
+StdDev 5
diff --git a/exams/AxelRubini/2025-01-09/3/results.txt b/exams/AxelRubini/2025-01-09/3/results.txt
new file mode 100644
index 0000000..78da49e
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/3/results.txt
@@ -0,0 +1,3 @@
+2025-01-09-Axel-Rubini-2158099
+Avg 99.9165
+StdDev 4.9439
diff --git a/exams/AxelRubini/2025-01-09/4/Makefile b/exams/AxelRubini/2025-01-09/4/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-01-09/4/include/DES.hpp b/exams/AxelRubini/2025-01-09/4/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/4/include/Decision.hpp b/exams/AxelRubini/2025-01-09/4/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/4/include/Dynamics.hpp b/exams/AxelRubini/2025-01-09/4/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/4/include/Geometry.hpp b/exams/AxelRubini/2025-01-09/4/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/4/include/IO.hpp b/exams/AxelRubini/2025-01-09/4/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/4/include/Inventory.hpp b/exams/AxelRubini/2025-01-09/4/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/4/include/Queue.hpp b/exams/AxelRubini/2025-01-09/4/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/4/include/Random.hpp b/exams/AxelRubini/2025-01-09/4/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/4/include/Stat.hpp b/exams/AxelRubini/2025-01-09/4/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/4/main b/exams/AxelRubini/2025-01-09/4/main
new file mode 100755
index 0000000000000000000000000000000000000000..af8698c9a67bf5b836346fb499dcf0f9f7f41778
GIT binary patch
literal 78288
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-01-09/4/main.cpp b/exams/AxelRubini/2025-01-09/4/main.cpp
new file mode 100644
index 0000000..97de4ea
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/main.cpp
@@ -0,0 +1,191 @@
+#include "include/DES.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include "include/Stat.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+class DispatcherCustomer : public DiscreteEventProcess {
+  public:
+    DispatcherCustomer(
+        int pid,
+        int dispatcherPid,
+        MessageBus &bus,
+        RandomGenerator &rng,
+        double avg,
+        double stddev
+    )
+        : pid_(pid), dispatcherPid_(dispatcherPid), bus_(bus), rng_(rng),
+          avg_(avg), stddev_(stddev) {}
+
+    void initialize(double startTime) override { scheduleNext(startTime); }
+
+    double nextEventTime() const override { return nextEventTime_; }
+
+    void handleEvent(double currentTime) override {
+        Message msg;
+        msg.time = currentTime;
+        msg.sender = pid_;
+        msg.receiver = dispatcherPid_;
+        bus_.procToNet(pid_).push(msg);
+
+        scheduleNext(currentTime);
+    }
+
+  private:
+    void scheduleNext(double currentTime) {
+        double delay = rng_.gaussian(avg_, stddev_);
+        if (delay < 1.0)
+            delay = 1.0; // T=1 is the minimum step
+        nextEventTime_ = currentTime + delay;
+    }
+
+    int pid_;
+    int dispatcherPid_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+    double avg_;
+    double stddev_;
+    double nextEventTime_;
+};
+
+class Dispatcher : public DiscreteEventProcess {
+  public:
+    Dispatcher(int pid, int monitorPid, int numCustomers, MessageBus &bus)
+        : pid_(pid), monitorPid_(monitorPid), numCustomers_(numCustomers),
+          bus_(bus) {
+        for (int i = 0; i < numCustomers; ++i) {
+            inputCounts_[i] = 0;
+        }
+    }
+
+    void initialize(double startTime) override {}
+
+    double nextEventTime() const override {
+        return std::numeric_limits<double>::infinity();
+    }
+
+    void handleEvent(double currentTime) override {}
+
+    void processInbox(double currentTime) {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            Message m = inbox.front();
+            inbox.pop();
+
+            if (m.sender >= 0 && m.sender < numCustomers_) {
+                inputCounts_[m.sender]++;
+            }
+
+            Message forward = m;
+            forward.sender = pid_;
+            forward.receiver = monitorPid_;
+            bus_.procToNet(pid_).push(forward);
+        }
+    }
+
+    int getCount(int customerId) const {
+        auto it = inputCounts_.find(customerId);
+        return it != inputCounts_.end() ? it->second : 0;
+    }
+
+  private:
+    int pid_;
+    int monitorPid_;
+    int numCustomers_;
+    MessageBus &bus_;
+    std::map<int, int> inputCounts_;
+};
+
+class DispatcherMonitor : public DiscreteEventProcess {
+  public:
+    DispatcherMonitor(int pid, MessageBus &bus)
+        : pid_(pid), bus_(bus), totalReceived_(0) {}
+
+    void initialize(double startTime) override {}
+
+    double nextEventTime() const override {
+        return std::numeric_limits<double>::infinity();
+    }
+
+    void handleEvent(double currentTime) override {}
+
+    void processInbox(double currentTime) {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            inbox.pop();
+            totalReceived_++;
+        }
+    }
+
+    int getTotalReceived() const { return totalReceived_; }
+
+  private:
+    int pid_;
+    MessageBus &bus_;
+    int totalReceived_;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng;
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt")) {
+        return 1;
+    }
+
+    int N = parser.getInt("N", 0);
+    double avg = parser.getDouble("Avg", 0.0);
+    double stddev = parser.getDouble("StdDev", 0.0);
+
+    int dispatcherPid = N;
+    int monitorPid = N + 1;
+    SELib::MessageBus bus(N + 2);
+    SELib::DiscreteEventSystem system;
+
+    for (int i = 0; i < N; ++i) {
+        system.emplaceProcess<SELib::DispatcherCustomer>(
+            i, dispatcherPid, bus, rng, avg, stddev
+        );
+    }
+    auto &dispatcher = system.emplaceProcess<SELib::Dispatcher>(
+        dispatcherPid, monitorPid, N, bus
+    );
+    auto &monitor =
+        system.emplaceProcess<SELib::DispatcherMonitor>(monitorPid, bus);
+    system.emplaceProcess<SELib::NetworkRouter>(
+        bus, rng, 0.1
+    ); // Back to a sane default
+
+    double currentTime = 0.0;
+    double horizon = 1000000.0;
+    system.initialize(0.0);
+
+    while (currentTime < horizon) {
+        double nextTime = system.nextEventTime();
+        if (nextTime > horizon)
+            break;
+        currentTime = nextTime;
+        system.handleEvent(currentTime);
+        dispatcher.processInbox(currentTime);
+        monitor.processInbox(currentTime);
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-01-09-Axel-Rubini-2158099" << std::endl;
+    for (int i = 0; i < N; ++i) {
+        outFile << (i + 1) << " " << dispatcher.getCount(i) << std::endl;
+    }
+    outFile << "M1 " << monitor.getTotalReceived() << std::endl;
+    outFile.close();
+
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-01-09/4/parameters.txt b/exams/AxelRubini/2025-01-09/4/parameters.txt
new file mode 100644
index 0000000..c1e8d88
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/parameters.txt
@@ -0,0 +1,3 @@
+N 7
+Avg 1500
+StdDev 150
diff --git a/exams/AxelRubini/2025-01-09/4/results.txt b/exams/AxelRubini/2025-01-09/4/results.txt
new file mode 100644
index 0000000..f991aaf
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/4/results.txt
@@ -0,0 +1,9 @@
+2025-01-09-Axel-Rubini-2158099
+1 666
+2 672
+3 669
+4 669
+5 667
+6 667
+7 664
+M1 4674
diff --git a/exams/AxelRubini/2025-01-09/5/Makefile b/exams/AxelRubini/2025-01-09/5/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-01-09/5/include/DES.hpp b/exams/AxelRubini/2025-01-09/5/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/5/include/Decision.hpp b/exams/AxelRubini/2025-01-09/5/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/5/include/Dynamics.hpp b/exams/AxelRubini/2025-01-09/5/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/5/include/Geometry.hpp b/exams/AxelRubini/2025-01-09/5/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/5/include/IO.hpp b/exams/AxelRubini/2025-01-09/5/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/5/include/Inventory.hpp b/exams/AxelRubini/2025-01-09/5/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/5/include/Queue.hpp b/exams/AxelRubini/2025-01-09/5/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/5/include/Random.hpp b/exams/AxelRubini/2025-01-09/5/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/5/include/Stat.hpp b/exams/AxelRubini/2025-01-09/5/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-01-09/5/main b/exams/AxelRubini/2025-01-09/5/main
new file mode 100755
index 0000000000000000000000000000000000000000..8f3c33ad50b9059cf7b20cca9c4f51cc8e7cf2ea
GIT binary patch
literal 87256
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
SEL-}U=g63oZ3%2YjsFKnaq4IQ

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-01-09/5/main.cpp b/exams/AxelRubini/2025-01-09/5/main.cpp
new file mode 100644
index 0000000..d68e7e3
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/main.cpp
@@ -0,0 +1,235 @@
+#include "include/DES.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include "include/Stat.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+class DispatcherCustomer : public DiscreteEventProcess {
+  public:
+    DispatcherCustomer(
+        int pid,
+        int dispatcherPid,
+        MessageBus &bus,
+        RandomGenerator &rng,
+        double avg,
+        double stddev
+    )
+        : pid_(pid), dispatcherPid_(dispatcherPid), bus_(bus), rng_(rng),
+          avg_(avg), stddev_(stddev) {}
+
+    void initialize(double startTime) override { scheduleNext(startTime); }
+
+    double nextEventTime() const override { return nextEventTime_; }
+
+    void handleEvent(double currentTime) override {
+        Message msg;
+        msg.time = currentTime;
+        msg.sender = pid_;
+        msg.receiver = dispatcherPid_;
+        bus_.procToNet(pid_).push(msg);
+
+        scheduleNext(currentTime);
+    }
+
+  private:
+    void scheduleNext(double currentTime) {
+        double delay = rng_.gaussian(avg_, stddev_);
+        if (delay < 1.0)
+            delay = 1.0;
+        nextEventTime_ = currentTime + delay;
+    }
+
+    int pid_;
+    int dispatcherPid_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+    double avg_;
+    double stddev_;
+    double nextEventTime_;
+};
+
+class Dispatcher : public DiscreteEventProcess {
+  public:
+    Dispatcher(int pid, int monitorPid, int numCustomers, MessageBus &bus)
+        : pid_(pid), monitorPid_(monitorPid), numCustomers_(numCustomers),
+          bus_(bus) {
+        for (int i = 0; i < numCustomers; ++i) {
+            inputCounts_[i] = 0;
+        }
+    }
+
+    void initialize(double startTime) override {}
+
+    double nextEventTime() const override {
+        return std::numeric_limits<double>::infinity();
+    }
+
+    void handleEvent(double currentTime) override {}
+
+    void processInbox(double currentTime) {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            buffer_.push_back(inbox.front());
+            inbox.pop();
+        }
+
+        // Release messages older than currentTime - 1.0
+        std::sort(
+            buffer_.begin(),
+            buffer_.end(),
+            [](const Message &a, const Message &b) { return a.time < b.time; }
+        );
+
+        auto it = std::lower_bound(
+            buffer_.begin(),
+            buffer_.end(),
+            currentTime - 1.0,
+            [](const Message &m, double t) { return m.time < t; }
+        );
+
+        std::vector<Message> toRelease(buffer_.begin(), it);
+        buffer_.erase(buffer_.begin(), it);
+
+        for (const auto &m : toRelease) {
+            if (m.sender >= 0 && m.sender < numCustomers_) {
+                inputCounts_[m.sender]++;
+            }
+
+            Message forward = m;
+            forward.sender = pid_;
+            forward.receiver = monitorPid_;
+            bus_.procToNet(pid_).push(forward);
+        }
+    }
+
+    void flushAll() {
+        std::sort(
+            buffer_.begin(),
+            buffer_.end(),
+            [](const Message &a, const Message &b) { return a.time < b.time; }
+        );
+        for (const auto &m : buffer_) {
+            if (m.sender >= 0 && m.sender < numCustomers_) {
+                inputCounts_[m.sender]++;
+            }
+            Message forward = m;
+            forward.sender = pid_;
+            forward.receiver = monitorPid_;
+            bus_.procToNet(pid_).push(forward);
+        }
+        buffer_.clear();
+    }
+
+    int getCount(int customerId) const {
+        auto it = inputCounts_.find(customerId);
+        return it != inputCounts_.end() ? it->second : 0;
+    }
+
+  private:
+    int pid_;
+    int monitorPid_;
+    int numCustomers_;
+    MessageBus &bus_;
+    std::map<int, int> inputCounts_;
+    std::vector<Message> buffer_;
+};
+
+class OrderMonitor : public DiscreteEventProcess {
+  public:
+    OrderMonitor(int pid, MessageBus &bus)
+        : pid_(pid), bus_(bus), lastTime_(-1.0), violated_(0) {}
+
+    void initialize(double startTime) override {}
+
+    double nextEventTime() const override {
+        return std::numeric_limits<double>::infinity();
+    }
+
+    void handleEvent(double currentTime) override {}
+
+    void processInbox(double currentTime) {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            Message m = inbox.front();
+            inbox.pop();
+
+            if (lastTime_ >= 0 && m.time < lastTime_) {
+                violated_ = 1;
+            }
+            lastTime_ = m.time;
+        }
+    }
+
+    int getViolated() const { return violated_; }
+
+  private:
+    int pid_;
+    MessageBus &bus_;
+    double lastTime_;
+    int violated_;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng;
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt")) {
+        return 1;
+    }
+
+    int N = parser.getInt("N", 0);
+    double avg = parser.getDouble("Avg", 0.0);
+    double stddev = parser.getDouble("StdDev", 0.0);
+
+    int dispatcherPid = N;
+    int monitorPid = N + 1;
+    SELib::MessageBus bus(N + 2);
+    SELib::DiscreteEventSystem system;
+
+    for (int i = 0; i < N; ++i) {
+        system.emplaceProcess<SELib::DispatcherCustomer>(
+            i, dispatcherPid, bus, rng, avg, stddev
+        );
+    }
+    auto &dispatcher = system.emplaceProcess<SELib::Dispatcher>(
+        dispatcherPid, monitorPid, N, bus
+    );
+    auto &monitor = system.emplaceProcess<SELib::OrderMonitor>(monitorPid, bus);
+    system.emplaceProcess<SELib::NetworkRouter>(bus, rng, 0.01);
+
+    double currentTime = 0.0;
+    double horizon = 1000000.0;
+    system.initialize(0.0);
+
+    while (currentTime < horizon) {
+        double nextTime = system.nextEventTime();
+        if (nextTime > horizon)
+            break;
+        currentTime = nextTime;
+        system.handleEvent(currentTime);
+        dispatcher.processInbox(currentTime);
+        monitor.processInbox(currentTime);
+    }
+    dispatcher.flushAll();
+    monitor.processInbox(currentTime);
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-01-09-Axel-Rubini-2158099" << std::endl;
+    for (int i = 0; i < N; ++i) {
+        outFile << (i + 1) << " " << dispatcher.getCount(i) << std::endl;
+    }
+    outFile << "M2 " << monitor.getViolated() << std::endl;
+    outFile.close();
+
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-01-09/5/parameters.txt b/exams/AxelRubini/2025-01-09/5/parameters.txt
new file mode 100644
index 0000000..ca68d86
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/parameters.txt
@@ -0,0 +1,3 @@
+N 10
+Avg 100
+StdDev 1
diff --git a/exams/AxelRubini/2025-01-09/5/results.txt b/exams/AxelRubini/2025-01-09/5/results.txt
new file mode 100644
index 0000000..34bfcd8
--- /dev/null
+++ b/exams/AxelRubini/2025-01-09/5/results.txt
@@ -0,0 +1,12 @@
+2025-01-09-Axel-Rubini-2158099
+1 10000
+2 9998
+3 10001
+4 9998
+5 10000
+6 10000
+7 9999
+8 9999
+9 9998
+10 9998
+M2 0
diff --git a/exams/AxelRubini/2025-02-05/1/Makefile b/exams/AxelRubini/2025-02-05/1/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-02-05/1/include/DES.hpp b/exams/AxelRubini/2025-02-05/1/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/1/include/Decision.hpp b/exams/AxelRubini/2025-02-05/1/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/1/include/Dynamics.hpp b/exams/AxelRubini/2025-02-05/1/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/1/include/Geometry.hpp b/exams/AxelRubini/2025-02-05/1/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/1/include/IO.hpp b/exams/AxelRubini/2025-02-05/1/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/1/include/Inventory.hpp b/exams/AxelRubini/2025-02-05/1/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/1/include/Queue.hpp b/exams/AxelRubini/2025-02-05/1/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/1/include/Random.hpp b/exams/AxelRubini/2025-02-05/1/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/1/include/Stat.hpp b/exams/AxelRubini/2025-02-05/1/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/1/main b/exams/AxelRubini/2025-02-05/1/main
new file mode 100755
index 0000000000000000000000000000000000000000..c6dae2fbfed4ecc63dda0384bf43c32994b0a74d
GIT binary patch
literal 76608
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-02-05/1/main.cpp b/exams/AxelRubini/2025-02-05/1/main.cpp
new file mode 100644
index 0000000..e1db30f
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/main.cpp
@@ -0,0 +1,165 @@
+#include "include/DES.hpp"
+#include "include/Geometry.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+class DroneProcess : public DiscreteEventProcess {
+  public:
+    DroneProcess(
+        int pid,
+        int monitorPid,
+        MessageBus &bus,
+        RandomGenerator &rng,
+        double X1,
+        double X2,
+        double Y1,
+        double Y2,
+        const std::vector<Point2D> &points
+    )
+        : pid_(pid), monitorPid_(monitorPid), bus_(bus), rng_(rng), X1_(X1),
+          X2_(X2), Y1_(Y1), Y2_(Y2), points_(points) {
+        pos_ = {rng_.uniform(X1_, X2_), rng_.uniform(Y1_, Y2_)};
+        nextTime_ = 0.0;
+    }
+
+    void initialize(double startTime) override { nextTime_ = startTime; }
+
+    double nextEventTime() const override { return nextTime_; }
+
+    void handleEvent(double currentTime) override {
+        for (size_t j = 0; j < points_.size(); ++j) {
+            if (pos_.x >= points_[j].x - 1.0 && pos_.x <= points_[j].x + 1.0 &&
+                pos_.y >= points_[j].y - 1.0 && pos_.y <= points_[j].y + 1.0) {
+                Message m;
+                m.time = currentTime;
+                m.sender = pid_;
+                m.receiver = monitorPid_;
+                m.item = (int)j;
+                m.quantity = 1.0;
+                bus_.procToNet(pid_).push(m);
+            }
+        }
+
+        double vx = rng_.uniform(-0.5, 0.5);
+        double vy = rng_.uniform(-0.5, 0.5);
+        pos_.x = std::min(X2_, std::max(X1_, pos_.x + vx));
+        pos_.y = std::min(Y2_, std::max(Y1_, pos_.y + vy));
+
+        nextTime_ += 1.0;
+    }
+
+  private:
+    int pid_, monitorPid_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+    double X1_, X2_, Y1_, Y2_;
+    const std::vector<Point2D> &points_;
+    Point2D pos_;
+    double nextTime_;
+};
+
+class MonitorProcess : public DiscreteEventProcess {
+  public:
+    MonitorProcess(int pid, int numPoints, int H, MessageBus &bus)
+        : pid_(pid), H_(H), bus_(bus) {
+        coverage_.assign(numPoints, 0.0);
+        currentCounts_.assign(numPoints, 0);
+        nextTime_ = 0.9;
+    }
+
+    void initialize(double startTime) override { nextTime_ = startTime + 0.9; }
+
+    double nextEventTime() const override { return nextTime_; }
+
+    void handleEvent(double currentTime) override {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            Message m = inbox.front();
+            inbox.pop();
+            if (m.item >= 0 && m.item < (int)currentCounts_.size()) {
+                currentCounts_[m.item]++;
+            }
+        }
+
+        int t = (int)nextTime_;
+        for (size_t j = 0; j < coverage_.size(); ++j) {
+            coverage_[j] = (coverage_[j] * t + currentCounts_[j]) / (t + 1);
+            currentCounts_[j] = 0;
+        }
+
+        nextTime_ += 1.0;
+    }
+
+    const std::vector<double> &getCoverage() const { return coverage_; }
+
+  private:
+    int pid_, H_;
+    MessageBus &bus_;
+    std::vector<double> coverage_;
+    std::vector<int> currentCounts_;
+    double nextTime_;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    int H = parser.getInt("H");
+    int N = parser.getInt("N");
+    double X1 = 0, X2 = 0, Y1 = 0, Y2 = 0;
+    const auto &structData = parser.getStructuredData();
+    for (const auto &line : structData) {
+        if (line.size() == 4 && line[0] != "H" && line[0] != "N" &&
+            line[0] != "M") {
+            X1 = std::stod(line[0]);
+            X2 = std::stod(line[1]);
+            Y1 = std::stod(line[2]);
+            Y2 = std::stod(line[3]);
+        }
+    }
+    std::vector<SELib::Point2D> points;
+    bool foundM = false;
+    for (const auto &line : structData) {
+        if (foundM && line.size() == 2) {
+            points.push_back({std::stod(line[0]), std::stod(line[1])});
+        }
+        if (line.size() == 2 && line[0] == "M")
+            foundM = true;
+    }
+
+    SELib::MessageBus bus(N + 1);
+    SELib::DiscreteEventSystem system;
+    for (int i = 0; i < N; ++i) {
+        system.emplaceProcess<SELib::DroneProcess>(
+            i, N, bus, rng, X1, X2, Y1, Y2, points
+        );
+    }
+    auto &monitor = system.emplaceProcess<SELib::MonitorProcess>(
+        N, (int)points.size(), H, bus
+    );
+    system.emplaceProcess<SELib::NetworkRouter>(bus, rng, 0.001);
+
+    SELib::DiscreteEventSimulator simulator(system);
+    simulator.run((double)H);
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-02-05-Axel-Rubini-2158099" << std::endl;
+    for (size_t i = 0; i < points.size(); ++i) {
+        outFile << points[i].x << " " << points[i].y << " " << std::fixed
+                << std::setprecision(4) << monitor.getCoverage()[i]
+                << std::endl;
+    }
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-02-05/1/parameters.txt b/exams/AxelRubini/2025-02-05/1/parameters.txt
new file mode 100644
index 0000000..276913a
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/parameters.txt
@@ -0,0 +1,9 @@
+H 10000
+N 10
+-5 5 -5 5
+M 5
+0 1
+0 -1
+0 0
+-1 0
+1 0
diff --git a/exams/AxelRubini/2025-02-05/1/results.txt b/exams/AxelRubini/2025-02-05/1/results.txt
new file mode 100644
index 0000000..a58ef0b
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/1/results.txt
@@ -0,0 +1,6 @@
+2025-02-05-Axel-Rubini-2158099
+0 1 0.3541
+0.0000 -1.0000 0.3702
+0.0000 0.0000 0.3507
+-1.0000 0.0000 0.3350
+1.0000 0.0000 0.3750
diff --git a/exams/AxelRubini/2025-02-05/2/Makefile b/exams/AxelRubini/2025-02-05/2/Makefile
new file mode 100644
index 0000000..6bc53bf
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
\ No newline at end of file
diff --git a/exams/AxelRubini/2025-02-05/2/include/DES.hpp b/exams/AxelRubini/2025-02-05/2/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/2/include/Decision.hpp b/exams/AxelRubini/2025-02-05/2/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/2/include/Dynamics.hpp b/exams/AxelRubini/2025-02-05/2/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/2/include/Geometry.hpp b/exams/AxelRubini/2025-02-05/2/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/2/include/IO.hpp b/exams/AxelRubini/2025-02-05/2/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/2/include/Inventory.hpp b/exams/AxelRubini/2025-02-05/2/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/2/include/Queue.hpp b/exams/AxelRubini/2025-02-05/2/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/2/include/Random.hpp b/exams/AxelRubini/2025-02-05/2/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/2/include/Stat.hpp b/exams/AxelRubini/2025-02-05/2/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/2/main b/exams/AxelRubini/2025-02-05/2/main
new file mode 100755
index 0000000000000000000000000000000000000000..e46da14cf888f85df9902452d6298da1c8b9a76a
GIT binary patch
literal 44016
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-02-05/2/main.cpp b/exams/AxelRubini/2025-02-05/2/main.cpp
new file mode 100644
index 0000000..fe0bac3
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/main.cpp
@@ -0,0 +1,187 @@
+#include "include/DES.hpp"
+#include "include/Decision.hpp"
+#include "include/Geometry.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+class DroneProcess : public DiscreteEventProcess {
+  public:
+    DroneProcess(
+        int pid,
+        int monitorPid,
+        MessageBus &bus,
+        RandomGenerator &rng,
+        double X1,
+        double X2,
+        double Y1,
+        double Y2,
+        const std::vector<Point2D> &points
+    )
+        : pid_(pid), monitorPid_(monitorPid), bus_(bus), rng_(rng), X1_(X1),
+          X2_(X2), Y1_(Y1), Y2_(Y2), points_(points) {
+        pos_ = {rng_.uniform(X1_, X2_), rng_.uniform(Y1_, Y2_)};
+        nextTime_ = 0.0;
+    }
+
+    void initialize(double startTime) override { nextTime_ = startTime; }
+
+    double nextEventTime() const override { return nextTime_; }
+
+    void handleEvent(double currentTime) override {
+        for (size_t j = 0; j < points_.size(); ++j) {
+            if (pos_.x >= points_[j].x - 1.0 && pos_.x <= points_[j].x + 1.0 &&
+                pos_.y >= points_[j].y - 1.0 && pos_.y <= points_[j].y + 1.0) {
+                Message m;
+                m.time = currentTime;
+                m.sender = pid_;
+                m.receiver = monitorPid_;
+                m.item = (int)j;
+                m.quantity = 1.0;
+                bus_.procToNet(pid_).push(m);
+            }
+        }
+
+        double vx = rng_.uniform(-0.5, 0.5);
+        double vy = rng_.uniform(-0.5, 0.5);
+        pos_.x = std::min(X2_, std::max(X1_, pos_.x + vx));
+        pos_.y = std::min(Y2_, std::max(Y1_, pos_.y + vy));
+
+        nextTime_ += 1.0;
+    }
+
+  private:
+    int pid_, monitorPid_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+    double X1_, X2_, Y1_, Y2_;
+    const std::vector<Point2D> &points_;
+    Point2D pos_;
+    double nextTime_;
+};
+
+class MonitorProcess : public DiscreteEventProcess {
+  public:
+    MonitorProcess(int pid, int numPoints, int H, MessageBus &bus)
+        : pid_(pid), H_(H), bus_(bus) {
+        coverage_.assign(numPoints, 0.0);
+        currentCounts_.assign(numPoints, 0);
+        nextTime_ = 0.9;
+    }
+
+    void initialize(double startTime) override { nextTime_ = startTime + 0.9; }
+
+    double nextEventTime() const override { return nextTime_; }
+
+    void handleEvent(double currentTime) override {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            Message m = inbox.front();
+            inbox.pop();
+            if (m.item >= 0 && m.item < (int)currentCounts_.size()) {
+                currentCounts_[m.item]++;
+            }
+        }
+
+        int t = (int)nextTime_;
+        for (size_t j = 0; j < coverage_.size(); ++j) {
+            coverage_[j] = (coverage_[j] * t + currentCounts_[j]) / (t + 1);
+            currentCounts_[j] = 0;
+        }
+
+        nextTime_ += 1.0;
+    }
+
+    const std::vector<double> &getCoverage() const { return coverage_; }
+
+  private:
+    int pid_, H_;
+    MessageBus &bus_;
+    std::vector<double> coverage_;
+    std::vector<int> currentCounts_;
+    double nextTime_;
+};
+
+bool runSimulation(
+    double C_threshold,
+    int H,
+    int N,
+    double X1,
+    double X2,
+    double Y1,
+    double Y2,
+    const std::vector<Point2D> &points,
+    RandomGenerator &rng
+) {
+    MessageBus bus(N + 1);
+    DiscreteEventSystem system;
+    for (int i = 0; i < N; ++i) {
+        system.emplaceProcess<DroneProcess>(
+            i, N, bus, rng, X1, X2, Y1, Y2, points
+        );
+    }
+    auto &monitor =
+        system.emplaceProcess<MonitorProcess>(N, (int)points.size(), H, bus);
+    system.emplaceProcess<NetworkRouter>(bus, rng, 0.001);
+
+    DiscreteEventSimulator simulator(system);
+    simulator.run((double)H);
+
+    for (double cov : monitor.getCoverage()) {
+        if (cov < C_threshold)
+            return false;
+    }
+    return true;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double C_threshold = parser.getDouble("C");
+    int H = parser.getInt("H");
+    int N = parser.getInt("N");
+    double X1 = 0, X2 = 0, Y1 = 0, Y2 = 0;
+    const auto &structData = parser.getStructuredData();
+    for (const auto &line : structData) {
+        if (line.size() == 4 && line[0] != "H" && line[0] != "N" &&
+            line[0] != "M" && line[0] != "C") {
+            X1 = std::stod(line[0]);
+            X2 = std::stod(line[1]);
+            Y1 = std::stod(line[2]);
+            Y2 = std::stod(line[3]);
+        }
+    }
+    std::vector<SELib::Point2D> points;
+    bool foundM = false;
+    for (const auto &line : structData) {
+        if (foundM && line.size() == 2) {
+            points.push_back({std::stod(line[0]), std::stod(line[1])});
+        }
+        if (line.size() == 2 && line[0] == "M")
+            foundM = true;
+    }
+
+    SELib::MonteCarloSimulator mc(1000);
+    double prob = mc.estimateProbability([&](int) {
+        return SELib::runSimulation(
+            C_threshold, H, N, X1, X2, Y1, Y2, points, rng
+        );
+    });
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-02-05-Axel-Rubini-2158099" << std::endl;
+    outFile << "P " << std::fixed << std::setprecision(4) << prob << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-02-05/2/parameters.txt b/exams/AxelRubini/2025-02-05/2/parameters.txt
new file mode 100644
index 0000000..b0ba50b
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/parameters.txt
@@ -0,0 +1,10 @@
+C 0.02
+H 10000
+N 10
+-5 5 -5 5
+M 5
+0 1
+0 -1
+0 0
+-1 0
+1 0
diff --git a/exams/AxelRubini/2025-02-05/2/results.txt b/exams/AxelRubini/2025-02-05/2/results.txt
new file mode 100644
index 0000000..434389d
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/2/results.txt
@@ -0,0 +1,2 @@
+2025-02-05-Axel-Rubini-2158099
+P 1
diff --git a/exams/AxelRubini/2025-02-05/3/Makefile b/exams/AxelRubini/2025-02-05/3/Makefile
new file mode 100644
index 0000000..6bc53bf
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
\ No newline at end of file
diff --git a/exams/AxelRubini/2025-02-05/3/include/DES.hpp b/exams/AxelRubini/2025-02-05/3/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/3/include/Decision.hpp b/exams/AxelRubini/2025-02-05/3/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/3/include/Dynamics.hpp b/exams/AxelRubini/2025-02-05/3/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/3/include/Geometry.hpp b/exams/AxelRubini/2025-02-05/3/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/3/include/IO.hpp b/exams/AxelRubini/2025-02-05/3/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/3/include/Inventory.hpp b/exams/AxelRubini/2025-02-05/3/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/3/include/Queue.hpp b/exams/AxelRubini/2025-02-05/3/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/3/include/Random.hpp b/exams/AxelRubini/2025-02-05/3/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/3/include/Stat.hpp b/exams/AxelRubini/2025-02-05/3/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/3/main b/exams/AxelRubini/2025-02-05/3/main
new file mode 100755
index 0000000000000000000000000000000000000000..dc8dc45ea2cd9f11f30c3e3aa49f3192dd799a3b
GIT binary patch
literal 43304
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
LX;Oitr1t*-Nt0N>

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-02-05/3/main.cpp b/exams/AxelRubini/2025-02-05/3/main.cpp
new file mode 100644
index 0000000..aa86bb1
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/main.cpp
@@ -0,0 +1,188 @@
+#include "include/DES.hpp"
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+class CustomerProcess : public DiscreteEventProcess {
+  public:
+    CustomerProcess(
+        int pid,
+        int serverPid,
+        MessageBus &bus,
+        RandomGenerator &rng,
+        const std::vector<std::vector<double>> &matrix
+    )
+        : pid_(pid), serverPid_(serverPid), bus_(bus), rng_(rng),
+          matrix_(matrix), currentState_(0), nextTime_(0.0) {}
+
+    void initialize(double startTime) override { nextTime_ = startTime; }
+    double nextEventTime() const override { return nextTime_; }
+
+    void handleEvent(double currentTime) override {
+        int nextState = rng_.discrete(matrix_[currentState_]);
+        bool isEndOfSession = (nextState == 0 && currentState_ != 0);
+
+        if (currentState_ != 0) {
+            Message m;
+            m.time = currentTime;
+            m.sender = pid_;
+            m.receiver = serverPid_;
+            m.item = currentState_;
+            m.quantity = isEndOfSession ? 1.0 : 0.0;
+            bus_.procToNet(pid_).push(m);
+        }
+        currentState_ = nextState;
+        nextTime_ += 1.0;
+    }
+
+  private:
+    int pid_, serverPid_, currentState_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+    const std::vector<std::vector<double>> &matrix_;
+    double nextTime_;
+};
+
+class ServerProcess : public DiscreteEventProcess {
+  public:
+    ServerProcess(
+        int pid,
+        int monitorPid,
+        MessageBus &bus,
+        double T1,
+        double T2
+    )
+        : pid_(pid), monitorPid_(monitorPid), bus_(bus), T1_(T1), T2_(T2),
+          serverFreeAt_(0.0),
+          nextFinishTime_(std::numeric_limits<double>::infinity()) {}
+
+    void initialize(double startTime) override {}
+    double nextEventTime() const override { return nextFinishTime_; }
+
+    void handleEvent(double currentTime) override {
+        if (currentTime >= nextFinishTime_) {
+            if (currentRequestIsLast_) {
+                Message m;
+                m.time = currentTime;
+                m.sender = pid_;
+                m.receiver = monitorPid_;
+                bus_.procToNet(pid_).push(m);
+            }
+            nextFinishTime_ = std::numeric_limits<double>::infinity();
+        }
+        processQueue(currentTime);
+    }
+
+    void processQueue(double currentTime) {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            queue_.push(inbox.front());
+            inbox.pop();
+        }
+
+        if (currentTime >= serverFreeAt_ && !queue_.empty()) {
+            Message req = queue_.front();
+            queue_.pop();
+            double st = (req.item == 1) ? T1_ : T2_;
+            serverFreeAt_ = std::max(currentTime, serverFreeAt_) + st;
+            nextFinishTime_ = serverFreeAt_;
+            currentRequestIsLast_ = (req.quantity > 0.5);
+        }
+    }
+
+  private:
+    int pid_, monitorPid_;
+    MessageBus &bus_;
+    double T1_, T2_, serverFreeAt_, nextFinishTime_;
+    bool currentRequestIsLast_;
+    std::queue<Message> queue_;
+};
+
+class MonitorProcess : public DiscreteEventProcess {
+  public:
+    MonitorProcess(int pid, MessageBus &bus)
+        : pid_(pid), bus_(bus), completed_(0) {}
+    void initialize(double startTime) override {}
+    double nextEventTime() const override {
+        return std::numeric_limits<double>::infinity();
+    }
+    void handleEvent(double currentTime) override {}
+    void processInbox() {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            inbox.pop();
+            completed_++;
+        }
+    }
+    int getCompleted() const { return completed_; }
+
+  private:
+    int pid_;
+    MessageBus &bus_;
+    int completed_;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    std::vector<std::vector<double>> matrix(3, std::vector<double>(3));
+    const auto &data = parser.getStructuredData();
+    for (const auto &line : data)
+        if (line.size() == 3)
+            matrix[std::stoi(line[0])][std::stoi(line[1])] = std::stod(line[2]);
+    std::vector<double> ts;
+    for (const auto &line : data)
+        if (line.size() == 1)
+            ts.push_back(std::stod(line[0]));
+    double T1 = ts[ts.size() - 2], T2 = ts[ts.size() - 1];
+
+    auto run_sim = [&](int simulations) {
+        double totalRate = 0;
+        for (int i = 0; i < simulations; ++i) {
+            SELib::MessageBus bus(3);
+            SELib::DiscreteEventSystem system;
+            system.emplaceProcess<SELib::CustomerProcess>(
+                0, 1, bus, rng, matrix
+            );
+            auto &server =
+                system.emplaceProcess<SELib::ServerProcess>(1, 2, bus, T1, T2);
+            auto &monitor =
+                system.emplaceProcess<SELib::MonitorProcess>(2, bus);
+            system.emplaceProcess<SELib::NetworkRouter>(bus, rng, 0.001);
+
+            double currentTime = 0.0, H = 10000.0;
+            system.initialize(0.0);
+            while (currentTime < H) {
+                double nextTime = system.nextEventTime();
+                if (nextTime > H)
+                    break;
+                currentTime = nextTime;
+                system.handleEvent(currentTime);
+                server.processQueue(currentTime);
+                monitor.processInbox();
+            }
+            totalRate += (double)monitor.getCompleted() / H;
+        }
+        return totalRate / simulations;
+    };
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-02-05-Axel-Rubini-2158099" << std::endl;
+    outFile << "Avg " << std::fixed << std::setprecision(4) << run_sim(1000)
+            << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-02-05/3/parameters.txt b/exams/AxelRubini/2025-02-05/3/parameters.txt
new file mode 100644
index 0000000..ba70834
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/parameters.txt
@@ -0,0 +1,11 @@
+0 0 0.40
+0 1 0.30
+0 2 0.30
+1 0 0.8
+1 1 0.1
+1 2 0.1
+2 0 0.8
+2 1 0.1
+2 2 0.1
+2.5
+4.5
diff --git a/exams/AxelRubini/2025-02-05/3/results.txt b/exams/AxelRubini/2025-02-05/3/results.txt
new file mode 100644
index 0000000..3b743b8
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/3/results.txt
@@ -0,0 +1,2 @@
+2025-02-05-Axel-Rubini-2158099
+Avg 0.3428
diff --git a/exams/AxelRubini/2025-02-05/4/Makefile b/exams/AxelRubini/2025-02-05/4/Makefile
new file mode 100644
index 0000000..6bc53bf
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
\ No newline at end of file
diff --git a/exams/AxelRubini/2025-02-05/4/include/DES.hpp b/exams/AxelRubini/2025-02-05/4/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/4/include/Decision.hpp b/exams/AxelRubini/2025-02-05/4/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/4/include/Dynamics.hpp b/exams/AxelRubini/2025-02-05/4/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/4/include/Geometry.hpp b/exams/AxelRubini/2025-02-05/4/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/4/include/IO.hpp b/exams/AxelRubini/2025-02-05/4/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/4/include/Inventory.hpp b/exams/AxelRubini/2025-02-05/4/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/4/include/Queue.hpp b/exams/AxelRubini/2025-02-05/4/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/4/include/Random.hpp b/exams/AxelRubini/2025-02-05/4/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/4/include/Stat.hpp b/exams/AxelRubini/2025-02-05/4/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/4/main b/exams/AxelRubini/2025-02-05/4/main
new file mode 100755
index 0000000000000000000000000000000000000000..5b98a875f3567516afe49b26fb0b8ded4cdb0850
GIT binary patch
literal 43440
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
LoTLItN$r0DT?;F-

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-02-05/4/main.cpp b/exams/AxelRubini/2025-02-05/4/main.cpp
new file mode 100644
index 0000000..8031838
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/main.cpp
@@ -0,0 +1,150 @@
+#include "include/DES.hpp"
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+class CustomerProcess : public DiscreteEventProcess {
+  public:
+    CustomerProcess(
+        int pid,
+        int serverPid,
+        MessageBus &bus,
+        RandomGenerator &rng,
+        const std::vector<std::vector<double>> &matrix
+    )
+        : pid_(pid), serverPid_(serverPid), bus_(bus), rng_(rng),
+          matrix_(matrix), currentState_(0), nextTime_(0.0) {}
+
+    void initialize(double startTime) override { nextTime_ = startTime; }
+    double nextEventTime() const override { return nextTime_; }
+
+    void handleEvent(double currentTime) override {
+        int nextState = rng_.discrete(matrix_[currentState_]);
+        if (currentState_ != 0) {
+            Message m;
+            m.time = currentTime;
+            m.sender = pid_;
+            m.receiver = serverPid_;
+            m.item = currentState_;
+            bus_.procToNet(pid_).push(m);
+        }
+        currentState_ = nextState;
+        nextTime_ += 1.0;
+    }
+
+  private:
+    int pid_, serverPid_, currentState_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+    const std::vector<std::vector<double>> &matrix_;
+    double nextTime_;
+};
+
+class ServerProcess : public DiscreteEventProcess {
+  public:
+    ServerProcess(int pid, MessageBus &bus, double T1, double T2)
+        : pid_(pid), bus_(bus), T1_(T1), T2_(T2), serverFreeAt_(0.0),
+          nextFinishTime_(std::numeric_limits<double>::infinity()) {}
+
+    void initialize(double startTime) override {}
+    double nextEventTime() const override { return nextFinishTime_; }
+
+    void handleEvent(double currentTime) override {
+        if (currentTime >= nextFinishTime_)
+            nextFinishTime_ = std::numeric_limits<double>::infinity();
+        processQueue(currentTime);
+    }
+
+    void processQueue(double currentTime) {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            queue_.push(inbox.front());
+            inbox.pop();
+        }
+
+        if (currentTime >= serverFreeAt_ && !queue_.empty()) {
+            Message req = queue_.front();
+            queue_.pop();
+            double st = (req.item == 1) ? T1_ : T2_;
+            serverFreeAt_ = std::max(currentTime, serverFreeAt_) + st;
+            nextFinishTime_ = serverFreeAt_;
+        }
+    }
+
+    size_t getQueueSize() const { return queue_.size(); }
+    bool isBusy() const {
+        return nextFinishTime_ != std::numeric_limits<double>::infinity();
+    }
+
+  private:
+    int pid_;
+    MessageBus &bus_;
+    double T1_, T2_, serverFreeAt_, nextFinishTime_;
+    std::queue<Message> queue_;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    std::vector<std::vector<double>> matrix(3, std::vector<double>(3));
+    const auto &data = parser.getStructuredData();
+    for (const auto &line : data)
+        if (line.size() == 3)
+            matrix[std::stoi(line[0])][std::stoi(line[1])] = std::stod(line[2]);
+    std::vector<double> ts;
+    for (const auto &line : data)
+        if (line.size() == 1)
+            ts.push_back(std::stod(line[0]));
+    double T1 = ts[ts.size() - 2], T2 = ts[ts.size() - 1];
+
+    auto run_sim = [&](int simulations) {
+        double totalAvgB = 0;
+        for (int i = 0; i < simulations; ++i) {
+            SELib::MessageBus bus(2);
+            SELib::DiscreteEventSystem system;
+            system.emplaceProcess<SELib::CustomerProcess>(
+                0, 1, bus, rng, matrix
+            );
+            auto &server =
+                system.emplaceProcess<SELib::ServerProcess>(1, bus, T1, T2);
+            system.emplaceProcess<SELib::NetworkRouter>(bus, rng, 0.001);
+
+            double currentTime = 0.0, H = 10000.0, area = 0.0;
+            system.initialize(0.0);
+            while (currentTime < H) {
+                double nextTime = system.nextEventTime();
+                if (nextTime > H)
+                    nextTime = H;
+                int B = (int)server.getQueueSize() + (server.isBusy() ? 1 : 0);
+                area += B * (nextTime - currentTime);
+                currentTime = nextTime;
+                if (currentTime >= H)
+                    break;
+                system.handleEvent(currentTime);
+                server.processQueue(currentTime);
+            }
+            totalAvgB += area / H;
+        }
+        return totalAvgB / simulations;
+    };
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-02-05-Axel-Rubini-2158099" << std::endl;
+    outFile << "Avg " << std::fixed << std::setprecision(4) << run_sim(1000)
+            << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-02-05/4/parameters.txt b/exams/AxelRubini/2025-02-05/4/parameters.txt
new file mode 100644
index 0000000..ba70834
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/parameters.txt
@@ -0,0 +1,11 @@
+0 0 0.40
+0 1 0.30
+0 2 0.30
+1 0 0.8
+1 1 0.1
+1 2 0.1
+2 0 0.8
+2 1 0.1
+2 2 0.1
+2.5
+4.5
diff --git a/exams/AxelRubini/2025-02-05/4/results.txt b/exams/AxelRubini/2025-02-05/4/results.txt
new file mode 100644
index 0000000..622c7e2
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/4/results.txt
@@ -0,0 +1,2 @@
+2025-02-05-Axel-Rubini-2158099
+Avg 715.882
diff --git a/exams/AxelRubini/2025-02-05/5/Makefile b/exams/AxelRubini/2025-02-05/5/Makefile
new file mode 100644
index 0000000..6bc53bf
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
\ No newline at end of file
diff --git a/exams/AxelRubini/2025-02-05/5/include/DES.hpp b/exams/AxelRubini/2025-02-05/5/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/5/include/Decision.hpp b/exams/AxelRubini/2025-02-05/5/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/5/include/Dynamics.hpp b/exams/AxelRubini/2025-02-05/5/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/5/include/Geometry.hpp b/exams/AxelRubini/2025-02-05/5/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/5/include/IO.hpp b/exams/AxelRubini/2025-02-05/5/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/5/include/Inventory.hpp b/exams/AxelRubini/2025-02-05/5/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/5/include/Queue.hpp b/exams/AxelRubini/2025-02-05/5/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/5/include/Random.hpp b/exams/AxelRubini/2025-02-05/5/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/5/include/Stat.hpp b/exams/AxelRubini/2025-02-05/5/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-02-05/5/main b/exams/AxelRubini/2025-02-05/5/main
new file mode 100755
index 0000000000000000000000000000000000000000..3c72e6ab97ea85e93b7a2ca8bc62c3341c1d1828
GIT binary patch
literal 43448
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
bywVx$dTkhvX~!&o{oN8{MoNK{r1rl6a>|rj

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-02-05/5/main.cpp b/exams/AxelRubini/2025-02-05/5/main.cpp
new file mode 100644
index 0000000..0d3bdd7
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/main.cpp
@@ -0,0 +1,152 @@
+#include "include/DES.hpp"
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+class CustomerProcess : public DiscreteEventProcess {
+  public:
+    CustomerProcess(
+        int pid,
+        int serverPid,
+        MessageBus &bus,
+        RandomGenerator &rng,
+        const std::vector<std::vector<double>> &matrix
+    )
+        : pid_(pid), serverPid_(serverPid), bus_(bus), rng_(rng),
+          matrix_(matrix), currentState_(0), nextTime_(0.0) {}
+
+    void initialize(double startTime) override { nextTime_ = startTime; }
+    double nextEventTime() const override { return nextTime_; }
+
+    void handleEvent(double currentTime) override {
+        int nextState = rng_.discrete(matrix_[currentState_]);
+        if (currentState_ != 0) {
+            Message m;
+            m.time = currentTime;
+            m.sender = pid_;
+            m.receiver = serverPid_;
+            m.item = currentState_;
+            bus_.procToNet(pid_).push(m);
+        }
+        currentState_ = nextState;
+        nextTime_ += 1.0;
+    }
+
+  private:
+    int pid_, serverPid_, currentState_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+    const std::vector<std::vector<double>> &matrix_;
+    double nextTime_;
+};
+
+class ServerProcess : public DiscreteEventProcess {
+  public:
+    ServerProcess(int pid, MessageBus &bus, double T1, double T2)
+        : pid_(pid), bus_(bus), T1_(T1), T2_(T2), serverFreeAt_(0.0),
+          nextFinishTime_(std::numeric_limits<double>::infinity()) {}
+
+    void initialize(double startTime) override {}
+    double nextEventTime() const override { return nextFinishTime_; }
+
+    void handleEvent(double currentTime) override {
+        if (currentTime >= nextFinishTime_)
+            nextFinishTime_ = std::numeric_limits<double>::infinity();
+        processQueue(currentTime);
+    }
+
+    void processQueue(double currentTime) {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            queue_.push(inbox.front());
+            inbox.pop();
+        }
+
+        if (currentTime >= serverFreeAt_ && !queue_.empty()) {
+            Message req = queue_.front();
+            queue_.pop();
+            double st = (req.item == 1) ? T1_ : T2_;
+            serverFreeAt_ = std::max(currentTime, serverFreeAt_) + st;
+            nextFinishTime_ = serverFreeAt_;
+        }
+    }
+
+    size_t getQueueSize() const { return queue_.size(); }
+    bool isBusy() const {
+        return nextFinishTime_ != std::numeric_limits<double>::infinity();
+    }
+
+  private:
+    int pid_;
+    MessageBus &bus_;
+    double T1_, T2_, serverFreeAt_, nextFinishTime_;
+    std::queue<Message> queue_;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double L_threshold = parser.getDouble("L");
+    std::vector<std::vector<double>> matrix(3, std::vector<double>(3));
+    const auto &data = parser.getStructuredData();
+    for (const auto &line : data)
+        if (line.size() == 3)
+            matrix[std::stoi(line[0])][std::stoi(line[1])] = std::stod(line[2]);
+    std::vector<double> ts;
+    for (const auto &line : data)
+        if (line.size() == 1 && line[0] != "L")
+            ts.push_back(std::stod(line[0]));
+    double T1 = ts[ts.size() - 2], T2 = ts[ts.size() - 1];
+
+    auto run_sim = [&](int simulations) {
+        double totalProb = 0;
+        for (int i = 0; i < simulations; ++i) {
+            SELib::MessageBus bus(2);
+            SELib::DiscreteEventSystem system;
+            system.emplaceProcess<SELib::CustomerProcess>(
+                0, 1, bus, rng, matrix
+            );
+            auto &server =
+                system.emplaceProcess<SELib::ServerProcess>(1, bus, T1, T2);
+            system.emplaceProcess<SELib::NetworkRouter>(bus, rng, 0.001);
+
+            double currentTime = 0.0, H = 10000.0, timeAboveL = 0.0;
+            system.initialize(0.0);
+            while (currentTime < H) {
+                double nextTime = system.nextEventTime();
+                if (nextTime > H)
+                    nextTime = H;
+                int B = (int)server.getQueueSize() + (server.isBusy() ? 1 : 0);
+                if (B > L_threshold)
+                    timeAboveL += (nextTime - currentTime);
+                currentTime = nextTime;
+                if (currentTime >= H)
+                    break;
+                system.handleEvent(currentTime);
+                server.processQueue(currentTime);
+            }
+            totalProb += (timeAboveL / H);
+        }
+        return totalProb / simulations;
+    };
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-02-05-Axel-Rubini-2158099" << std::endl;
+    outFile << "P " << std::fixed << std::setprecision(4) << run_sim(1000)
+            << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-02-05/5/parameters.txt b/exams/AxelRubini/2025-02-05/5/parameters.txt
new file mode 100644
index 0000000..ec8fa29
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/parameters.txt
@@ -0,0 +1,12 @@
+L 893
+0 0 0.40
+0 1 0.30
+0 2 0.30
+1 0 0.8
+1 1 0.1
+1 2 0.1
+2 0 0.8
+2 1 0.1
+2 2 0.1
+2.5
+4.5
diff --git a/exams/AxelRubini/2025-02-05/5/results.txt b/exams/AxelRubini/2025-02-05/5/results.txt
new file mode 100644
index 0000000..1b6dfc2
--- /dev/null
+++ b/exams/AxelRubini/2025-02-05/5/results.txt
@@ -0,0 +1,2 @@
+2025-02-05-Axel-Rubini-2158099
+P 0.375374
diff --git a/exams/AxelRubini/2025-03-21/1/Makefile b/exams/AxelRubini/2025-03-21/1/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-03-21/1/include/DES.hpp b/exams/AxelRubini/2025-03-21/1/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/1/include/Decision.hpp b/exams/AxelRubini/2025-03-21/1/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/1/include/Dynamics.hpp b/exams/AxelRubini/2025-03-21/1/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/1/include/Geometry.hpp b/exams/AxelRubini/2025-03-21/1/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/1/include/IO.hpp b/exams/AxelRubini/2025-03-21/1/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/1/include/Inventory.hpp b/exams/AxelRubini/2025-03-21/1/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/1/include/Queue.hpp b/exams/AxelRubini/2025-03-21/1/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/1/include/Random.hpp b/exams/AxelRubini/2025-03-21/1/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/1/include/Stat.hpp b/exams/AxelRubini/2025-03-21/1/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/1/main b/exams/AxelRubini/2025-03-21/1/main
new file mode 100755
index 0000000000000000000000000000000000000000..3137e490f60ff45d19100d86d75d8211851fa9e3
GIT binary patch
literal 43512
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
HDk=THr{Ph~

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-03-21/1/main.cpp b/exams/AxelRubini/2025-03-21/1/main.cpp
new file mode 100644
index 0000000..6e3469e
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/main.cpp
@@ -0,0 +1,98 @@
+#include "include/Geometry.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Drone {
+    int id;
+    Point3D pos;
+    bool operative;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    int H = parser.getInt("H");
+    int N = parser.getInt("N");
+    double alpha = parser.getDouble("A");
+    double R = parser.getDouble("R");
+
+    double X1 = 0, X2 = 0, Y1 = 0, Y2 = 0, Z1 = 0, Z2 = 0;
+    const auto &data = parser.getStructuredData();
+    for (const auto &line : data) {
+        if (line.size() == 6) {
+            X1 = std::stod(line[0]);
+            X2 = std::stod(line[1]);
+            Y1 = std::stod(line[2]);
+            Y2 = std::stod(line[3]);
+            Z1 = std::stod(line[4]);
+            Z2 = std::stod(line[5]);
+        }
+    }
+
+    std::vector<SELib::Drone> drones(N);
+    for (int i = 0; i < N; ++i) {
+        drones[i].id = i;
+        drones[i].pos = {
+            rng.uniform(X1, X2), rng.uniform(Y1, Y2), rng.uniform(Z1, Z2)
+        };
+        drones[i].operative = true;
+    }
+
+    for (int t = 0; t < H; ++t) {
+        // 1. Check collisions (before movement? usually yes)
+        std::vector<bool> collisionThisStep(N, false);
+        for (int i = 0; i < N; ++i) {
+            if (!drones[i].operative)
+                continue;
+            for (int j = i + 1; j < N; ++j) {
+                if (!drones[j].operative)
+                    continue;
+                if (drones[i].pos.distanceTo(drones[j].pos) <= R) {
+                    collisionThisStep[i] = true;
+                    collisionThisStep[j] = true;
+                }
+            }
+        }
+        for (int i = 0; i < N; ++i) {
+            if (collisionThisStep[i])
+                drones[i].operative = false;
+        }
+
+        // 2. Move drones
+        for (int i = 0; i < N; ++i) {
+            if (!drones[i].operative)
+                continue;
+            double vx = rng.uniform(-alpha, alpha);
+            double vy = rng.uniform(-alpha, alpha);
+            double vz = rng.uniform(-alpha, alpha);
+            drones[i].pos.x = std::min(X2, std::max(X1, drones[i].pos.x + vx));
+            drones[i].pos.y = std::min(Y2, std::max(Y1, drones[i].pos.y + vy));
+            drones[i].pos.z = std::min(Z2, std::max(Z1, drones[i].pos.z + vz));
+        }
+    }
+
+    int Q = 0;
+    for (int i = 0; i < N; ++i)
+        if (drones[i].operative)
+            Q++;
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-03-21-Axel-Rubini-2158099" << std::endl;
+    outFile << "Q " << Q << std::endl;
+    outFile << "N " << N << std::endl;
+    outFile << "P " << (double)Q / N << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-03-21/1/parameters.txt b/exams/AxelRubini/2025-03-21/1/parameters.txt
new file mode 100644
index 0000000..22aa83b
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/parameters.txt
@@ -0,0 +1,5 @@
+H 100000
+N 1000
+A 0.2
+R 0.1
+-10 10 -10 10 -10 10
diff --git a/exams/AxelRubini/2025-03-21/1/results.txt b/exams/AxelRubini/2025-03-21/1/results.txt
new file mode 100644
index 0000000..6b23883
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/1/results.txt
@@ -0,0 +1,4 @@
+2025-03-21-Axel-Rubini-2158099
+Q 22
+N 1000
+P 0.022
diff --git a/exams/AxelRubini/2025-03-21/2/Makefile b/exams/AxelRubini/2025-03-21/2/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-03-21/2/include/DES.hpp b/exams/AxelRubini/2025-03-21/2/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/2/include/Decision.hpp b/exams/AxelRubini/2025-03-21/2/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/2/include/Dynamics.hpp b/exams/AxelRubini/2025-03-21/2/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/2/include/Geometry.hpp b/exams/AxelRubini/2025-03-21/2/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/2/include/IO.hpp b/exams/AxelRubini/2025-03-21/2/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/2/include/Inventory.hpp b/exams/AxelRubini/2025-03-21/2/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/2/include/Queue.hpp b/exams/AxelRubini/2025-03-21/2/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/2/include/Random.hpp b/exams/AxelRubini/2025-03-21/2/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/2/include/Stat.hpp b/exams/AxelRubini/2025-03-21/2/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/2/main b/exams/AxelRubini/2025-03-21/2/main
new file mode 100755
index 0000000000000000000000000000000000000000..4a6c69185785f910436e80caf77f06e3506bd8fa
GIT binary patch
literal 43504
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-03-21/2/main.cpp b/exams/AxelRubini/2025-03-21/2/main.cpp
new file mode 100644
index 0000000..62e6904
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/main.cpp
@@ -0,0 +1,124 @@
+#include "include/Geometry.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Drone {
+    int id;
+    Point3D pos;
+    bool operative;
+};
+
+double runOneSimulation(
+    double alpha,
+    int H,
+    int N,
+    double R,
+    double X1,
+    double X2,
+    double Y1,
+    double Y2,
+    double Z1,
+    double Z2,
+    RandomGenerator &rng
+) {
+    std::vector<Drone> drones(N);
+    for (int i = 0; i < N; ++i) {
+        drones[i].id = i;
+        drones[i].pos = {
+            rng.uniform(X1, X2), rng.uniform(Y1, Y2), rng.uniform(Z1, Z2)
+        };
+        drones[i].operative = true;
+    }
+
+    for (int t = 0; t < H; ++t) {
+        std::vector<bool> col(N, false);
+        for (int i = 0; i < N; ++i) {
+            if (!drones[i].operative)
+                continue;
+            for (int j = i + 1; j < N; ++j) {
+                if (!drones[j].operative)
+                    continue;
+                if (drones[i].pos.distanceTo(drones[j].pos) <= R) {
+                    col[i] = col[j] = true;
+                }
+            }
+        }
+        for (int i = 0; i < N; ++i)
+            if (col[i])
+                drones[i].operative = false;
+
+        for (int i = 0; i < N; ++i) {
+            if (!drones[i].operative)
+                continue;
+            drones[i].pos.x = std::min(
+                X2, std::max(X1, drones[i].pos.x + rng.uniform(-alpha, alpha))
+            );
+            drones[i].pos.y = std::min(
+                Y2, std::max(Y1, drones[i].pos.y + rng.uniform(-alpha, alpha))
+            );
+            drones[i].pos.z = std::min(
+                Z2, std::max(Z1, drones[i].pos.z + rng.uniform(-alpha, alpha))
+            );
+        }
+    }
+
+    int Q = 0;
+    for (int i = 0; i < N; ++i)
+        if (drones[i].operative)
+            Q++;
+    return (double)Q / N;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    int H = parser.getInt("H");
+    int N = parser.getInt("N");
+    double R = parser.getDouble("R");
+
+    double X1 = 0, X2 = 0, Y1 = 0, Y2 = 0, Z1 = 0, Z2 = 0;
+    const auto &data = parser.getStructuredData();
+    for (const auto &line : data) {
+        if (line.size() == 6) {
+            X1 = std::stod(line[0]);
+            X2 = std::stod(line[1]);
+            Y1 = std::stod(line[2]);
+            Y2 = std::stod(line[3]);
+            Z1 = std::stod(line[4]);
+            Z2 = std::stod(line[5]);
+        }
+    }
+
+    double bestP = -1.0;
+    double bestAlpha = 0.0;
+
+    for (int i = 0; i < 1000; ++i) {
+        double alpha = rng.uniform(0.1, 0.5);
+        double P = SELib::runOneSimulation(
+            alpha, H, N, R, X1, X2, Y1, Y2, Z1, Z2, rng
+        );
+        if (P > bestP) {
+            bestP = P;
+            bestAlpha = alpha;
+        }
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-03-21-Axel-Rubini-2158099" << std::endl;
+    outFile << "P " << bestP << std::endl;
+    outFile << "A " << bestAlpha << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-03-21/2/parameters.txt b/exams/AxelRubini/2025-03-21/2/parameters.txt
new file mode 100644
index 0000000..ffaf90c
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/parameters.txt
@@ -0,0 +1,5 @@
+H 10000
+N 200
+A 0.2
+R 0.1
+-4.0 4.0 -4.0 4.0 -4.0 4.0
diff --git a/exams/AxelRubini/2025-03-21/2/results.txt b/exams/AxelRubini/2025-03-21/2/results.txt
new file mode 100644
index 0000000..cd2a981
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/2/results.txt
@@ -0,0 +1,3 @@
+2025-03-21-Axel-Rubini-2158099
+P 0.13
+A 0.100715
diff --git a/exams/AxelRubini/2025-03-21/3/Makefile b/exams/AxelRubini/2025-03-21/3/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-03-21/3/include/DES.hpp b/exams/AxelRubini/2025-03-21/3/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/3/include/Decision.hpp b/exams/AxelRubini/2025-03-21/3/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/3/include/Dynamics.hpp b/exams/AxelRubini/2025-03-21/3/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/3/include/Geometry.hpp b/exams/AxelRubini/2025-03-21/3/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/3/include/IO.hpp b/exams/AxelRubini/2025-03-21/3/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/3/include/Inventory.hpp b/exams/AxelRubini/2025-03-21/3/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/3/include/Queue.hpp b/exams/AxelRubini/2025-03-21/3/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/3/include/Random.hpp b/exams/AxelRubini/2025-03-21/3/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/3/include/Stat.hpp b/exams/AxelRubini/2025-03-21/3/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/3/main b/exams/AxelRubini/2025-03-21/3/main
new file mode 100755
index 0000000000000000000000000000000000000000..71167aab8ae8454ce4877a8b54d0b9a7ac0ddae0
GIT binary patch
literal 47248
zcmeIb34B|{wLgAkTZw_h*MR_LX%Rd@?FNixXR#9kc48%0AcGs5U{=Mk<=78zwdKTN
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
U_uYmutofx(&6-eQLQ?zx0GZxi{Qv*}

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-03-21/3/main.cpp b/exams/AxelRubini/2025-03-21/3/main.cpp
new file mode 100644
index 0000000..7ec0e6a
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/main.cpp
@@ -0,0 +1,104 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Server {
+    std::vector<int> cache;
+    std::vector<int> soldLocally;
+    std::queue<int> inputQueue;
+    int busyUntil;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    const auto &data = parser.getStructuredData();
+    int H = std::stoi(data[0][0]);
+    int n = std::stoi(data[1][0]);
+    int k = std::stoi(data[2][0]);
+    double alpha = std::stod(data[3][0]);
+
+    std::vector<double> p, f;
+    for (const auto &s : data[4])
+        p.push_back(std::stod(s));
+    for (const auto &s : data[5])
+        f.push_back(std::stod(s));
+
+    long long totalS = 0;
+    int simulations = 1000;
+
+    for (int sim = 0; sim < simulations; ++sim) {
+        std::vector<int> centralDB(k + 1, 0);
+        std::vector<SELib::Server> servers(n);
+        for (int i = 0; i < n; ++i) {
+            servers[i].cache.assign(k + 1, 0);
+            servers[i].soldLocally.assign(k + 1, 0);
+            servers[i].busyUntil = 0;
+        }
+
+        long long oversellings = 0;
+
+        for (int t = 0; t < H; ++t) {
+            // 1. Supplier
+            int supItem = rng.discrete(f);
+            if (supItem != 0)
+                centralDB[supItem]++;
+
+            // 2. Customers & Server
+            for (int i = 0; i < n; ++i) {
+                int item = rng.discrete(p);
+                if (item != 0)
+                    servers[i].inputQueue.push(item);
+
+                if (t >= servers[i].busyUntil) {
+                    if (!servers[i].inputQueue.empty()) {
+                        int reqItem = servers[i].inputQueue.front();
+                        servers[i].inputQueue.pop();
+
+                        if (servers[i].cache[reqItem] -
+                                servers[i].soldLocally[reqItem] >
+                            0) {
+                            servers[i].soldLocally[reqItem]++;
+                        }
+
+                        if (rng.bernoulli(alpha)) {
+                            servers[i].busyUntil = t + 10;
+                            for (int j = 1; j <= k; ++j) {
+                                centralDB[j] -= servers[i].soldLocally[j];
+                                if (centralDB[j] < 0) {
+                                    oversellings += std::abs(centralDB[j]);
+                                    centralDB[j] = 0;
+                                }
+                                servers[i].soldLocally[j] = 0;
+                                servers[i].cache[j] = centralDB[j];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        totalS += oversellings;
+    }
+
+    double finalS = (double)totalS / simulations;
+    double finalR = finalS / (n * H);
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-03-21-Axel-Rubini-2158099" << std::endl;
+    outFile << "S " << (long long)finalS << std::endl;
+    outFile << "R " << finalR << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-03-21/3/parameters.txt b/exams/AxelRubini/2025-03-21/3/parameters.txt
new file mode 100644
index 0000000..61af210
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/parameters.txt
@@ -0,0 +1,6 @@
+100000
+3
+2
+1.0
+0.0 0.5 0.5
+1.0 0.0 0.0
diff --git a/exams/AxelRubini/2025-03-21/3/results.txt b/exams/AxelRubini/2025-03-21/3/results.txt
new file mode 100644
index 0000000..fce4174
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/3/results.txt
@@ -0,0 +1,3 @@
+2025-03-21-Axel-Rubini-2158099
+S 0
+R 0
diff --git a/exams/AxelRubini/2025-03-21/4/Makefile b/exams/AxelRubini/2025-03-21/4/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-03-21/4/include/DES.hpp b/exams/AxelRubini/2025-03-21/4/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/4/include/Decision.hpp b/exams/AxelRubini/2025-03-21/4/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/4/include/Dynamics.hpp b/exams/AxelRubini/2025-03-21/4/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/4/include/Geometry.hpp b/exams/AxelRubini/2025-03-21/4/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/4/include/IO.hpp b/exams/AxelRubini/2025-03-21/4/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/4/include/Inventory.hpp b/exams/AxelRubini/2025-03-21/4/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/4/include/Queue.hpp b/exams/AxelRubini/2025-03-21/4/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/4/include/Random.hpp b/exams/AxelRubini/2025-03-21/4/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/4/include/Stat.hpp b/exams/AxelRubini/2025-03-21/4/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/4/main b/exams/AxelRubini/2025-03-21/4/main
new file mode 100755
index 0000000000000000000000000000000000000000..877203349182a59d877de1459d5f436583580ae2
GIT binary patch
literal 47248
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-03-21/4/main.cpp b/exams/AxelRubini/2025-03-21/4/main.cpp
new file mode 100644
index 0000000..58006ae
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/main.cpp
@@ -0,0 +1,102 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Server {
+    std::vector<int> cache;
+    std::vector<int> soldLocally;
+    std::queue<int> inputQueue;
+    int busyUntil;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    const auto &data = parser.getStructuredData();
+    int H = std::stoi(data[0][0]);
+    int n = std::stoi(data[1][0]);
+    int k = std::stoi(data[2][0]);
+    double alpha = std::stod(data[3][0]);
+
+    std::vector<double> p, f;
+    for (const auto &s : data[4])
+        p.push_back(std::stod(s));
+    for (const auto &s : data[5])
+        f.push_back(std::stod(s));
+
+    long long totalZ = 0;
+    int simulations = 1000;
+
+    for (int sim = 0; sim < simulations; ++sim) {
+        std::vector<int> centralDB(k + 1, 0);
+        std::vector<SELib::Server> servers(n);
+        for (int i = 0; i < n; ++i) {
+            servers[i].cache.assign(k + 1, 0);
+            servers[i].soldLocally.assign(k + 1, 0);
+            servers[i].busyUntil = 0;
+        }
+
+        long long transactions = 0;
+
+        for (int t = 0; t < H; ++t) {
+            int supItem = rng.discrete(f);
+            if (supItem != 0)
+                centralDB[supItem]++;
+
+            for (int i = 0; i < n; ++i) {
+                int item = rng.discrete(p);
+                if (item != 0)
+                    servers[i].inputQueue.push(item);
+
+                if (t >= servers[i].busyUntil) {
+                    if (!servers[i].inputQueue.empty()) {
+                        int reqItem = servers[i].inputQueue.front();
+                        servers[i].inputQueue.pop();
+
+                        transactions++; // Transazione completata
+
+                        if (servers[i].cache[reqItem] -
+                                servers[i].soldLocally[reqItem] >
+                            0) {
+                            servers[i].soldLocally[reqItem]++;
+                        }
+
+                        if (rng.bernoulli(alpha)) {
+                            servers[i].busyUntil = t + 10;
+                            for (int j = 1; j <= k; ++j) {
+                                centralDB[j] -= servers[i].soldLocally[j];
+                                if (centralDB[j] < 0)
+                                    centralDB[j] = 0;
+                                servers[i].soldLocally[j] = 0;
+                                servers[i].cache[j] = centralDB[j];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        totalZ += transactions;
+    }
+
+    double finalZ = (double)totalZ / simulations;
+    double finalW = finalZ / (n * H);
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-03-21-Axel-Rubini-2158099" << std::endl;
+    outFile << "Z " << (long long)finalZ << std::endl;
+    outFile << "W " << finalW << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-03-21/4/parameters.txt b/exams/AxelRubini/2025-03-21/4/parameters.txt
new file mode 100644
index 0000000..f2566c7
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/parameters.txt
@@ -0,0 +1,6 @@
+10000
+5
+2
+0.5
+0.8 0.1 0.1
+0.6 0.2 0.2
diff --git a/exams/AxelRubini/2025-03-21/4/results.txt b/exams/AxelRubini/2025-03-21/4/results.txt
new file mode 100644
index 0000000..1595d3f
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/4/results.txt
@@ -0,0 +1,3 @@
+2025-03-21-Axel-Rubini-2158099
+Z 9059
+W 0.181191
diff --git a/exams/AxelRubini/2025-03-21/5/Makefile b/exams/AxelRubini/2025-03-21/5/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-03-21/5/include/DES.hpp b/exams/AxelRubini/2025-03-21/5/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/5/include/Decision.hpp b/exams/AxelRubini/2025-03-21/5/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/5/include/Dynamics.hpp b/exams/AxelRubini/2025-03-21/5/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/5/include/Geometry.hpp b/exams/AxelRubini/2025-03-21/5/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/5/include/IO.hpp b/exams/AxelRubini/2025-03-21/5/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/5/include/Inventory.hpp b/exams/AxelRubini/2025-03-21/5/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/5/include/Queue.hpp b/exams/AxelRubini/2025-03-21/5/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/5/include/Random.hpp b/exams/AxelRubini/2025-03-21/5/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/5/include/Stat.hpp b/exams/AxelRubini/2025-03-21/5/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-03-21/5/main b/exams/AxelRubini/2025-03-21/5/main
new file mode 100755
index 0000000000000000000000000000000000000000..8e580c8a80cc008d5ea99c5953699d844c75b491
GIT binary patch
literal 47432
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-03-21/5/main.cpp b/exams/AxelRubini/2025-03-21/5/main.cpp
new file mode 100644
index 0000000..f4b7239
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/main.cpp
@@ -0,0 +1,124 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Server {
+    std::vector<int> cache;
+    std::vector<int> soldLocally;
+    std::queue<int> inputQueue;
+    int busyUntil;
+};
+
+struct Metrics {
+    double W, S, J;
+};
+
+Metrics runOneSim(
+    double alpha,
+    int H,
+    int n,
+    int k,
+    const std::vector<double> &p,
+    const std::vector<double> &f,
+    RandomGenerator &rng
+) {
+    std::vector<int> centralDB(k + 1, 0);
+    std::vector<Server> servers(n);
+    for (int i = 0; i < n; ++i) {
+        servers[i].cache.assign(k + 1, 0);
+        servers[i].soldLocally.assign(k + 1, 0);
+        servers[i].busyUntil = 0;
+    }
+
+    long long oversellings = 0;
+    long long transactions = 0;
+
+    for (int t = 0; t < H; ++t) {
+        int supItem = rng.discrete(f);
+        if (supItem != 0)
+            centralDB[supItem]++;
+
+        for (int i = 0; i < n; ++i) {
+            int item = rng.discrete(p);
+            if (item != 0)
+                servers[i].inputQueue.push(item);
+
+            if (t >= servers[i].busyUntil) {
+                if (!servers[i].inputQueue.empty()) {
+                    int reqItem = servers[i].inputQueue.front();
+                    servers[i].inputQueue.pop();
+                    transactions++;
+                    if (servers[i].cache[reqItem] -
+                            servers[i].soldLocally[reqItem] >
+                        0) {
+                        servers[i].soldLocally[reqItem]++;
+                    }
+                    if (rng.bernoulli(alpha)) {
+                        servers[i].busyUntil = t + 10;
+                        for (int j = 1; j <= k; ++j) {
+                            centralDB[j] -= servers[i].soldLocally[j];
+                            if (centralDB[j] < 0) {
+                                oversellings += std::abs(centralDB[j]);
+                                centralDB[j] = 0;
+                            }
+                            servers[i].soldLocally[j] = 0;
+                            servers[i].cache[j] = centralDB[j];
+                        }
+                    }
+                }
+            }
+        }
+    }
+    double W = (double)transactions / (n * H);
+    double S = (double)oversellings / (n * H);
+    return {W, S, W - S};
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    const auto &data = parser.getStructuredData();
+    int H = std::stoi(data[0][0]);
+    int n = std::stoi(data[1][0]);
+    int k = std::stoi(data[2][0]);
+    // alpha is absent in Ex 5 params
+
+    std::vector<double> p, f;
+    for (const auto &s : data[3])
+        p.push_back(std::stod(s));
+    for (const auto &s : data[4])
+        f.push_back(std::stod(s));
+
+    double bestAlpha = 0;
+    SELib::Metrics bestM = {0, 0, -1e18};
+
+    for (int i = 0; i < 1000; ++i) {
+        double alpha = rng.uniform(0.0, 1.0);
+        auto m = SELib::runOneSim(alpha, H, n, k, p, f, rng);
+        if (m.J > bestM.J) {
+            bestM = m;
+            bestAlpha = alpha;
+        }
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-03-21-Axel-Rubini-2158099" << std::endl;
+    outFile << "A " << bestAlpha << std::endl;
+    outFile << "W " << bestM.W << std::endl;
+    outFile << "S " << bestM.S << std::endl;
+    outFile << "J " << bestM.J << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-03-21/5/parameters.txt b/exams/AxelRubini/2025-03-21/5/parameters.txt
new file mode 100644
index 0000000..67c8b42
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/parameters.txt
@@ -0,0 +1,5 @@
+100000
+5
+2
+0.0 0.5 0.5
+1.0 0.0 0.0
diff --git a/exams/AxelRubini/2025-03-21/5/results.txt b/exams/AxelRubini/2025-03-21/5/results.txt
new file mode 100644
index 0000000..b095cb6
--- /dev/null
+++ b/exams/AxelRubini/2025-03-21/5/results.txt
@@ -0,0 +1,5 @@
+2025-03-21-Axel-Rubini-2158099
+A 0.00239006
+W 0.978616
+S 0
+J 0.978616
diff --git a/exams/AxelRubini/2025-06-12/1/Makefile b/exams/AxelRubini/2025-06-12/1/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-06-12/1/include/DES.hpp b/exams/AxelRubini/2025-06-12/1/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/1/include/Decision.hpp b/exams/AxelRubini/2025-06-12/1/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/1/include/Dynamics.hpp b/exams/AxelRubini/2025-06-12/1/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/1/include/Geometry.hpp b/exams/AxelRubini/2025-06-12/1/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/1/include/IO.hpp b/exams/AxelRubini/2025-06-12/1/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/1/include/Inventory.hpp b/exams/AxelRubini/2025-06-12/1/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/1/include/Queue.hpp b/exams/AxelRubini/2025-06-12/1/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/1/include/Random.hpp b/exams/AxelRubini/2025-06-12/1/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/1/include/Stat.hpp b/exams/AxelRubini/2025-06-12/1/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/1/main b/exams/AxelRubini/2025-06-12/1/main
new file mode 100755
index 0000000000000000000000000000000000000000..c18031bec2bd8000b84a229caa08bbab7c2d4edc
GIT binary patch
literal 38904
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-06-12/1/main.cpp b/exams/AxelRubini/2025-06-12/1/main.cpp
new file mode 100644
index 0000000..3c24a59
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/main.cpp
@@ -0,0 +1,51 @@
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+struct UV {
+    int id;
+    double x, y;
+};
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double H = parser.getDouble("H");
+    int N = parser.getInt("N");
+    double V = parser.getDouble("V");
+    double T = parser.getDouble("T");
+
+    std::vector<SELib::UV> vehicles(N);
+    for (int i = 0; i < N; ++i) {
+        vehicles[i].id = i + 1;
+        vehicles[i].x = rng.uniform(-10.0, 10.0);
+        vehicles[i].y = rng.uniform(-10.0, 10.0);
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-06-12-Axel-Rubini-2158099" << std::endl;
+
+    for (double t = 0; t <= H + 1e-9; t += T) {
+        for (int i = 0; i < N; ++i) {
+            outFile << t << " " << vehicles[i].id << " " << vehicles[i].x << " "
+                    << vehicles[i].y << std::endl;
+        }
+        for (int i = 0; i < N; ++i) {
+            double theta = rng.uniform(0.0, 2.0 * M_PI);
+            vehicles[i].x += T * V * std::sin(theta);
+            vehicles[i].y += T * V * std::cos(theta);
+        }
+    }
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-06-12/1/parameters.txt b/exams/AxelRubini/2025-06-12/1/parameters.txt
new file mode 100644
index 0000000..019b143
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/parameters.txt
@@ -0,0 +1,4 @@
+H 5
+N 2
+V 1.0
+T 2
diff --git a/exams/AxelRubini/2025-06-12/1/results.txt b/exams/AxelRubini/2025-06-12/1/results.txt
new file mode 100644
index 0000000..148a506
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/1/results.txt
@@ -0,0 +1,7 @@
+2025-06-12-Axel-Rubini-2158099
+0 1 1.85689 6.88531
+0 2 7.15891 6.94503
+2 1 0.455499 5.4584
+2 2 8.48735 5.44996
+4 1 2.36696 4.8699
+4 2 9.18504 7.32432
diff --git a/exams/AxelRubini/2025-06-12/2/Makefile b/exams/AxelRubini/2025-06-12/2/Makefile
new file mode 100644
index 0000000..4daac4d
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/Makefile
@@ -0,0 +1,7 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+all: main
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-06-12/2/include/DES.hpp b/exams/AxelRubini/2025-06-12/2/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/2/include/Decision.hpp b/exams/AxelRubini/2025-06-12/2/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/2/include/Dynamics.hpp b/exams/AxelRubini/2025-06-12/2/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/2/include/Geometry.hpp b/exams/AxelRubini/2025-06-12/2/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/2/include/IO.hpp b/exams/AxelRubini/2025-06-12/2/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/2/include/Inventory.hpp b/exams/AxelRubini/2025-06-12/2/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/2/include/Queue.hpp b/exams/AxelRubini/2025-06-12/2/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/2/include/Random.hpp b/exams/AxelRubini/2025-06-12/2/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/2/include/Stat.hpp b/exams/AxelRubini/2025-06-12/2/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/2/main b/exams/AxelRubini/2025-06-12/2/main
new file mode 100755
index 0000000000000000000000000000000000000000..206b76ee1ee08ceff909eed11c0f647c56e51573
GIT binary patch
literal 43352
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
X)N8<SY@4+F1^07|qJ#noN$LLpZz#gA

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-06-12/2/main.cpp b/exams/AxelRubini/2025-06-12/2/main.cpp
new file mode 100644
index 0000000..539bdb6
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/main.cpp
@@ -0,0 +1,103 @@
+#include "include/Geometry.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+struct UV {
+    Point2D pos;
+};
+
+double runOneSimulation(
+    double H,
+    int N,
+    double V,
+    double T,
+    double R,
+    double L,
+    RandomGenerator &rng
+) {
+    std::vector<UV> vehicles(N);
+    for (int i = 0; i < N; ++i)
+        vehicles[i].pos = {rng.uniform(-10.0, 10.0), rng.uniform(-10.0, 10.0)};
+
+    int collisionSteps = 0;
+    for (double t = T; t <= H + 1e-9; t += T) {
+        int qCounts[4] = {0, 0, 0, 0};
+        for (int i = 1; i < N; ++i) {
+            if (vehicles[0].pos.distanceTo(vehicles[i].pos) <= R) {
+                double dx = vehicles[i].pos.x - vehicles[0].pos.x;
+                double dy = vehicles[i].pos.y - vehicles[0].pos.y;
+                if (dx >= 0 && dy >= 0)
+                    qCounts[0]++;
+                else if (dx >= 0 && dy <= 0)
+                    qCounts[1]++;
+                else if (dx <= 0 && dy <= 0)
+                    qCounts[2]++;
+                else if (dx <= 0 && dy >= 0)
+                    qCounts[3]++;
+            }
+        }
+        int bestQ = 0;
+        for (int k = 1; k < 4; ++k)
+            if (qCounts[k] > qCounts[bestQ])
+                bestQ = k;
+
+        double theta1 =
+            rng.uniform(bestQ * M_PI / 2.0, (bestQ + 1) * M_PI / 2.0);
+        vehicles[0].pos.x += T * V * std::sin(theta1);
+        vehicles[0].pos.y += T * V * std::cos(theta1);
+
+        for (int i = 1; i < N; ++i) {
+            double theta = rng.uniform(0.0, 2.0 * M_PI);
+            vehicles[i].pos.x += T * V * std::sin(theta);
+            vehicles[i].pos.y += T * V * std::cos(theta);
+        }
+
+        bool hit = false;
+        for (int i = 1; i < N; ++i) {
+            if (vehicles[0].pos.distanceTo(vehicles[i].pos) <=
+                L) { // Use L for collision
+                hit = true;
+                break;
+            }
+        }
+        if (hit)
+            collisionSteps++;
+    }
+    if (collisionSteps == 0)
+        return H;
+    return H / (double)collisionSteps;
+}
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+    double H = parser.getDouble("H"), V = parser.getDouble("V"),
+           T = parser.getDouble("T");
+    int N = parser.getInt("N");
+    double R = 1.0, L = 0.1;
+    const auto &data = parser.getStructuredData();
+    for (const auto &line : data) {
+        if (line.size() == 2 && line[0] == "R")
+            R = std::stod(line[1]);
+        if (line.size() == 2 && line[0] == "L")
+            L = std::stod(line[1]);
+    }
+    double totalC = 0;
+    for (int i = 0; i < 1000; ++i)
+        totalC += SELib::runOneSimulation(H, N, V, T, R, L, rng);
+    std::ofstream outFile("results.txt");
+    outFile << "2025-06-12-Axel-Rubini-2158099" << std::endl;
+    outFile << "C " << totalC / 1000.0 << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-06-12/2/parameters.txt b/exams/AxelRubini/2025-06-12/2/parameters.txt
new file mode 100644
index 0000000..87db89b
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/parameters.txt
@@ -0,0 +1,6 @@
+H 10
+N 10
+V 2
+T 1
+R 5
+L 3
diff --git a/exams/AxelRubini/2025-06-12/2/results.txt b/exams/AxelRubini/2025-06-12/2/results.txt
new file mode 100644
index 0000000..f9e0512
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/2/results.txt
@@ -0,0 +1,2 @@
+2025-06-12-Axel-Rubini-2158099
+C 2.3714
diff --git a/exams/AxelRubini/2025-06-12/3/Makefile b/exams/AxelRubini/2025-06-12/3/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-06-12/3/include/DES.hpp b/exams/AxelRubini/2025-06-12/3/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/3/include/Decision.hpp b/exams/AxelRubini/2025-06-12/3/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/3/include/Dynamics.hpp b/exams/AxelRubini/2025-06-12/3/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/3/include/Geometry.hpp b/exams/AxelRubini/2025-06-12/3/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/3/include/IO.hpp b/exams/AxelRubini/2025-06-12/3/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/3/include/Inventory.hpp b/exams/AxelRubini/2025-06-12/3/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/3/include/Queue.hpp b/exams/AxelRubini/2025-06-12/3/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/3/include/Random.hpp b/exams/AxelRubini/2025-06-12/3/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/3/include/Stat.hpp b/exams/AxelRubini/2025-06-12/3/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/3/main b/exams/AxelRubini/2025-06-12/3/main
new file mode 100755
index 0000000000000000000000000000000000000000..949af51a5932188d023482f6df9b78c4e5379e15
GIT binary patch
literal 39088
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-06-12/3/main.cpp b/exams/AxelRubini/2025-06-12/3/main.cpp
new file mode 100644
index 0000000..b3bd952
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/main.cpp
@@ -0,0 +1,33 @@
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double H = parser.getDouble("H");
+    int N = parser.getInt("N");
+    double A = parser.getDouble("A");
+    double B = parser.getDouble("B");
+    double T = parser.getDouble("T");
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-06-12-Axel-Rubini-2158099" << std::endl;
+
+    double nextReq = 0.0;
+    for (double t = 0; t <= H + 1e-9; t += T) {
+        if (t >= nextReq - 1e-9) {
+            outFile << t << " " << rng.uniformInt(1, N) << std::endl;
+            nextReq = t + rng.uniform(A, B);
+        } else {
+            outFile << t << " 0" << std::endl;
+        }
+    }
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-06-12/3/parameters.txt b/exams/AxelRubini/2025-06-12/3/parameters.txt
new file mode 100644
index 0000000..0c4c10d
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/parameters.txt
@@ -0,0 +1,5 @@
+H 10
+N 5
+A 1
+B 3
+T 1
diff --git a/exams/AxelRubini/2025-06-12/3/results.txt b/exams/AxelRubini/2025-06-12/3/results.txt
new file mode 100644
index 0000000..99307bb
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/3/results.txt
@@ -0,0 +1,12 @@
+2025-06-12-Axel-Rubini-2158099
+0 3
+1 0
+2 0
+3 5
+4 0
+5 0
+6 3
+7 0
+8 4
+9 0
+10 3
diff --git a/exams/AxelRubini/2025-06-12/4/Makefile b/exams/AxelRubini/2025-06-12/4/Makefile
new file mode 100644
index 0000000..4daac4d
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/Makefile
@@ -0,0 +1,7 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+all: main
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-06-12/4/include/DES.hpp b/exams/AxelRubini/2025-06-12/4/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/4/include/Decision.hpp b/exams/AxelRubini/2025-06-12/4/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/4/include/Dynamics.hpp b/exams/AxelRubini/2025-06-12/4/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/4/include/Geometry.hpp b/exams/AxelRubini/2025-06-12/4/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/4/include/IO.hpp b/exams/AxelRubini/2025-06-12/4/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/4/include/Inventory.hpp b/exams/AxelRubini/2025-06-12/4/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/4/include/Queue.hpp b/exams/AxelRubini/2025-06-12/4/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/4/include/Random.hpp b/exams/AxelRubini/2025-06-12/4/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/4/include/Stat.hpp b/exams/AxelRubini/2025-06-12/4/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/4/main b/exams/AxelRubini/2025-06-12/4/main
new file mode 100755
index 0000000000000000000000000000000000000000..1e29aab2f2f1ed6d0d8fbf23028a33b4feba7c18
GIT binary patch
literal 44192
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-06-12/4/main.cpp b/exams/AxelRubini/2025-06-12/4/main.cpp
new file mode 100644
index 0000000..b0988d3
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/main.cpp
@@ -0,0 +1,100 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+struct Server {
+    std::vector<int> inventory;
+    double busyUntil;
+};
+struct Event {
+    double time;
+    int type; // 0: Cust, 1: Disp->Serv, 2: Serv->Disp
+    int sender, receiver, productId, status;
+    bool operator>(const Event &other) const { return time > other.time; }
+};
+
+double runOneSim(
+    int H,
+    int N,
+    double A,
+    double B,
+    int S,
+    int K,
+    double p,
+    double D,
+    double F,
+    RandomGenerator &rng
+) {
+    std::priority_queue<Event, std::vector<Event>, std::greater<Event>> eq;
+    std::vector<Server> servers(S);
+    for (int i = 0; i < S; ++i) {
+        servers[i].inventory.assign(N + 1, 0);
+        for (int j = 1; j <= N; ++j)
+            servers[i].inventory[j] = rng.uniformInt(1, K);
+        servers[i].busyUntil = 0;
+    }
+    eq.push({0.0, 0, 0, 0, rng.uniformInt(1, N), 0});
+    long long failed = 0, total = 0;
+
+    while (!eq.empty()) {
+        Event e = eq.top();
+        eq.pop();
+        if (e.time > H)
+            break;
+        if (e.type == 0) {
+            eq.push(
+                {e.time + D, 1, 0, rng.uniformInt(0, S - 1), e.productId, 0}
+            );
+            eq.push(
+                {e.time + rng.uniform(A, B), 0, 0, 0, rng.uniformInt(1, N), 0}
+            );
+        } else if (e.type == 1) {
+            total++;
+            double finish = std::max(e.time, servers[e.receiver].busyUntil) + F;
+            servers[e.receiver].busyUntil = finish;
+            int status = (servers[e.receiver].inventory[e.productId] > 0);
+            if (status)
+                servers[e.receiver].inventory[e.productId]--;
+            eq.push({finish, 2, e.receiver, 0, e.productId, status});
+        } else if (e.type == 2) {
+            if (e.status == 0) {
+                failed++;
+                if (rng.bernoulli(p))
+                    servers[e.sender].inventory[e.productId] += 10;
+                else
+                    servers[rng.uniformInt(0, S - 1)]
+                        .inventory[rng.uniformInt(1, N)] += 10;
+            }
+        }
+    }
+    return total == 0 ? 0 : (double)failed / total;
+}
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+    int M = parser.getInt("M"), H = (int)parser.getDouble("H"),
+        N = parser.getInt("N"), S = parser.getInt("S"), K = parser.getInt("K");
+    double A = parser.getDouble("A"), B = parser.getDouble("B"),
+           p = parser.getDouble("p"), D = parser.getDouble("D"),
+           F = parser.getDouble("F");
+
+    double totalQ = 0;
+    for (int i = 0; i < M; ++i)
+        totalQ += SELib::runOneSim(H, N, A, B, S, K, p, D, F, rng);
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-06-12-Axel-Rubini-2158099" << std::endl;
+    outFile << "Q " << totalQ / M << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-06-12/4/parameters.txt b/exams/AxelRubini/2025-06-12/4/parameters.txt
new file mode 100644
index 0000000..1cfe221
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/parameters.txt
@@ -0,0 +1,11 @@
+M 1
+H 100000
+N 2
+A 1.0
+B 1.0
+T 1.0
+S 3
+K 0
+p 0
+D 1
+F 2
diff --git a/exams/AxelRubini/2025-06-12/4/results.txt b/exams/AxelRubini/2025-06-12/4/results.txt
new file mode 100644
index 0000000..2772682
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/4/results.txt
@@ -0,0 +1,2 @@
+2025-06-12-Axel-Rubini-2158099
+Q 0.09119
diff --git a/exams/AxelRubini/2025-06-12/5/Makefile b/exams/AxelRubini/2025-06-12/5/Makefile
new file mode 100644
index 0000000..4daac4d
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/Makefile
@@ -0,0 +1,7 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+all: main
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-06-12/5/include/DES.hpp b/exams/AxelRubini/2025-06-12/5/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/5/include/Decision.hpp b/exams/AxelRubini/2025-06-12/5/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/5/include/Dynamics.hpp b/exams/AxelRubini/2025-06-12/5/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/5/include/Geometry.hpp b/exams/AxelRubini/2025-06-12/5/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/5/include/IO.hpp b/exams/AxelRubini/2025-06-12/5/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/5/include/Inventory.hpp b/exams/AxelRubini/2025-06-12/5/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/5/include/Queue.hpp b/exams/AxelRubini/2025-06-12/5/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/5/include/Random.hpp b/exams/AxelRubini/2025-06-12/5/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/5/include/Stat.hpp b/exams/AxelRubini/2025-06-12/5/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-06-12/5/main b/exams/AxelRubini/2025-06-12/5/main
new file mode 100755
index 0000000000000000000000000000000000000000..165cc204c3569000cd638af574530effe022659b
GIT binary patch
literal 48288
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
a)(iA@_55(W3{=15zc@xlM1_c~^#1^GEV;)3

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-06-12/5/main.cpp b/exams/AxelRubini/2025-06-12/5/main.cpp
new file mode 100644
index 0000000..444c985
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/main.cpp
@@ -0,0 +1,116 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+struct Server {
+    std::vector<int> inventory;
+    double busyUntil;
+};
+struct Event {
+    double time;
+    int type; // 0: Cust, 1: Disp->Serv, 2: Serv->Disp
+    int sender, receiver, productId, status;
+    bool operator>(const Event &other) const { return time > other.time; }
+};
+
+double runMsims(
+    double p,
+    int M,
+    int H,
+    int N,
+    double A,
+    double B,
+    int S,
+    int K,
+    double D,
+    double F,
+    RandomGenerator &rng
+) {
+    double totalQ = 0;
+    for (int m = 0; m < M; ++m) {
+        std::priority_queue<Event, std::vector<Event>, std::greater<Event>> eq;
+        std::vector<Server> servers(S);
+        for (int i = 0; i < S; ++i) {
+            servers[i].inventory.assign(N + 1, 0);
+            for (int j = 1; j <= N; ++j)
+                servers[i].inventory[j] = rng.uniformInt(1, K);
+            servers[i].busyUntil = 0;
+        }
+        eq.push({0.0, 0, 0, 0, rng.uniformInt(1, N), 0});
+        long long failed = 0, total = 0;
+        while (!eq.empty()) {
+            Event e = eq.top();
+            eq.pop();
+            if (e.time > H)
+                break;
+            if (e.type == 0) {
+                eq.push(
+                    {e.time + D, 1, 0, rng.uniformInt(0, S - 1), e.productId, 0}
+                );
+                eq.push(
+                    {e.time + rng.uniform(A, B),
+                     0,
+                     0,
+                     0,
+                     rng.uniformInt(1, N),
+                     0}
+                );
+            } else if (e.type == 1) {
+                total++;
+                double finish =
+                    std::max(e.time, servers[e.receiver].busyUntil) + F;
+                servers[e.receiver].busyUntil = finish;
+                int status = (servers[e.receiver].inventory[e.productId] > 0);
+                if (status)
+                    servers[e.receiver].inventory[e.productId]--;
+                eq.push({finish, 2, e.receiver, 0, e.productId, status});
+            } else if (e.type == 2) {
+                if (e.status == 0) {
+                    failed++;
+                    if (rng.bernoulli(p))
+                        servers[e.sender].inventory[e.productId] += 10;
+                    else
+                        servers[rng.uniformInt(0, S - 1)]
+                            .inventory[rng.uniformInt(1, N)] += 10;
+                }
+            }
+        }
+        totalQ += (total == 0 ? 0 : (double)failed / total);
+    }
+    return totalQ / M;
+}
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+    int M = parser.getInt("M"), W = parser.getInt("W"),
+        H = (int)parser.getDouble("H"), N = parser.getInt("N"),
+        S = parser.getInt("S"), K = parser.getInt("K");
+    double A = parser.getDouble("A"), B = parser.getDouble("B"),
+           D = parser.getDouble("D"), F = parser.getDouble("F");
+
+    double bestP = 0, minQ = 1e18;
+    for (int i = 0; i < W; ++i) {
+        double p = rng.uniform(0.0, 1.0);
+        double q = SELib::runMsims(p, M, H, N, A, B, S, K, D, F, rng);
+        if (q < minQ) {
+            minQ = q;
+            bestP = p;
+        }
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-06-12-Axel-Rubini-2158099" << std::endl;
+    outFile << "P " << bestP << " Q " << minQ << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-06-12/5/parameters.txt b/exams/AxelRubini/2025-06-12/5/parameters.txt
new file mode 100644
index 0000000..7b6f139
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/parameters.txt
@@ -0,0 +1,11 @@
+M 10
+W 10
+H 100000
+N 3
+A 1.0
+B 1.0
+T 1
+S 10
+K 1
+D 1
+F 2
diff --git a/exams/AxelRubini/2025-06-12/5/results.txt b/exams/AxelRubini/2025-06-12/5/results.txt
new file mode 100644
index 0000000..96b2468
--- /dev/null
+++ b/exams/AxelRubini/2025-06-12/5/results.txt
@@ -0,0 +1,2 @@
+2025-06-12-Axel-Rubini-2158099
+P 0.846262 Q 0.091049
diff --git a/exams/AxelRubini/2025-07-08/1/Makefile b/exams/AxelRubini/2025-07-08/1/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-07-08/1/include/DES.hpp b/exams/AxelRubini/2025-07-08/1/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/1/include/Decision.hpp b/exams/AxelRubini/2025-07-08/1/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/1/include/Dynamics.hpp b/exams/AxelRubini/2025-07-08/1/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/1/include/Geometry.hpp b/exams/AxelRubini/2025-07-08/1/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/1/include/IO.hpp b/exams/AxelRubini/2025-07-08/1/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/1/include/Inventory.hpp b/exams/AxelRubini/2025-07-08/1/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/1/include/Queue.hpp b/exams/AxelRubini/2025-07-08/1/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/1/include/Random.hpp b/exams/AxelRubini/2025-07-08/1/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/1/include/Stat.hpp b/exams/AxelRubini/2025-07-08/1/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/1/main b/exams/AxelRubini/2025-07-08/1/main
new file mode 100755
index 0000000000000000000000000000000000000000..cf3429a7c3d3b45c4fb53b2fc5cbd03fa8bb4d69
GIT binary patch
literal 43808
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
Vbr_D}qn1DX?;ImLqCiAa`hT#EQ$YX#

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-07-08/1/main.cpp b/exams/AxelRubini/2025-07-08/1/main.cpp
new file mode 100644
index 0000000..a767bfd
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/main.cpp
@@ -0,0 +1,149 @@
+#include "include/Geometry.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct UV {
+    Point2D pos;
+    Point2D target;
+};
+
+double calculateFi(int i, const std::vector<UV> &vehicles, double A) {
+    double term1 = 0;
+    term1 = std::pow(vehicles[i].pos.x - vehicles[i].target.x, 2) +
+            std::pow(vehicles[i].pos.y - vehicles[i].target.y, 2);
+
+    double term2 = 0;
+    for (int j = 0; j < (int)vehicles.size(); ++j) {
+        if (i == j)
+            continue;
+        term2 += std::pow(vehicles[j].pos.x - vehicles[i].pos.x, 2) +
+                 std::pow(vehicles[j].pos.y - vehicles[i].pos.y, 2);
+    }
+    return A * term1 - (1.0 - A) * term2;
+}
+
+double runOneSimulation(
+    double H,
+    int M,
+    int N,
+    double A,
+    double V,
+    int Q,
+    double T,
+    RandomGenerator &rng
+) {
+    std::vector<UV> vehicles(N);
+    for (int i = 0; i < N; ++i) {
+        vehicles[i].pos = {rng.uniform(-50.0, 50.0), rng.uniform(-50.0, 50.0)};
+        double targetVal = -50.0 + 100.0 * (double)i / (N - 1);
+        if (N == 1)
+            targetVal = -50.0;
+        vehicles[i].target = {targetVal, targetVal};
+    }
+
+    long long totalCollisions = 0;
+    double time = 0.0;
+
+    while (time < H - 1e-9) {
+        std::vector<double> bestThetas(N);
+        for (int i = 0; i < N; ++i) {
+            double minFi = 1e18;
+            double bestTheta = 0;
+            for (int q = 0; q < Q; ++q) {
+                double theta = (double)q / Q * 2.0 * M_PI;
+                // Temporary move to evaluate Fi
+                UV temp = vehicles[i];
+                temp.pos.x += T * V * std::sin(theta);
+                temp.pos.y += T * V * std::cos(theta);
+
+                // We need to update ALL positions to evaluate Fi(X(t+T))?
+                // Text: "Al tempo t... sceglie theta... che minimizza Fi(X(t))"
+                // Fi depends on current distances.
+                double val = calculateFi(i, vehicles, A); // Based on X(t)
+                // Wait, if Fi depends on X(t), it doesn't depend on the chosen
+                // theta! Re-reading: "minizza il valore della funzione
+                // Fi(X(t))" is likely a typo for Fi(X(t+T)). Or maybe Fi(X)
+                // where X is the state after moving only vehicle i? Let's
+                // assume Fi is evaluated at the potential new position of
+                // vehicle i.
+
+                double potentialX = vehicles[i].pos.x + T * V * std::sin(theta);
+                double potentialY = vehicles[i].pos.y + T * V * std::cos(theta);
+
+                double t1 = std::pow(potentialX - vehicles[i].target.x, 2) +
+                            std::pow(potentialY - vehicles[i].target.y, 2);
+                double t2 = 0;
+                for (int j = 0; j < N; ++j) {
+                    if (i == j)
+                        continue;
+                    t2 += std::pow(vehicles[j].pos.x - potentialX, 2) +
+                          std::pow(vehicles[j].pos.y - potentialY, 2);
+                }
+                double fi = A * t1 - (1.0 - A) * t2;
+                if (fi < minFi) {
+                    minFi = fi;
+                    bestTheta = theta;
+                }
+            }
+            bestThetas[i] = bestTheta;
+        }
+
+        // Apply movement with noise
+        double noiseLimit = M_PI / Q;
+        for (int i = 0; i < N; ++i) {
+            double w1 = rng.uniform(-noiseLimit, noiseLimit);
+            double w2 = rng.uniform(-noiseLimit, noiseLimit);
+            vehicles[i].pos.x += T * V * std::sin(bestThetas[i] + w1);
+            vehicles[i].pos.y += T * V * std::cos(bestThetas[i] + w2);
+        }
+
+        time += T;
+
+        // Check collisions
+        for (int i = 0; i < N; ++i) {
+            for (int j = i + 1; j < N; ++j) {
+                if (vehicles[i].pos.distanceTo(vehicles[j].pos) <= 0.1) {
+                    totalCollisions++;
+                }
+            }
+        }
+    }
+
+    return (double)totalCollisions / H;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double H = parser.getDouble("H");
+    int M = parser.getInt("M");
+    int N = parser.getInt("N");
+    double A = parser.getDouble("A");
+    double V = parser.getDouble("V");
+    int Q = parser.getInt("Q");
+    double T = parser.getDouble("T");
+
+    double totalRate = 0;
+    for (int i = 0; i < M; ++i) {
+        totalRate += SELib::runOneSimulation(H, M, N, A, V, Q, T, rng);
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-07-08-Axel-Rubini-2158099" << std::endl;
+    outFile << "C " << totalRate / M << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-07-08/1/parameters.txt b/exams/AxelRubini/2025-07-08/1/parameters.txt
new file mode 100644
index 0000000..72e246c
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/parameters.txt
@@ -0,0 +1,7 @@
+H 1000
+M 10
+N 100
+A 1
+V 0.1
+Q 30
+T 1
diff --git a/exams/AxelRubini/2025-07-08/1/results.txt b/exams/AxelRubini/2025-07-08/1/results.txt
new file mode 100644
index 0000000..157ddbb
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/1/results.txt
@@ -0,0 +1,2 @@
+2025-07-08-Axel-Rubini-2158099
+C 0.0201
diff --git a/exams/AxelRubini/2025-07-08/2/Makefile b/exams/AxelRubini/2025-07-08/2/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-07-08/2/include/DES.hpp b/exams/AxelRubini/2025-07-08/2/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/2/include/Decision.hpp b/exams/AxelRubini/2025-07-08/2/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/2/include/Dynamics.hpp b/exams/AxelRubini/2025-07-08/2/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/2/include/Geometry.hpp b/exams/AxelRubini/2025-07-08/2/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/2/include/IO.hpp b/exams/AxelRubini/2025-07-08/2/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/2/include/Inventory.hpp b/exams/AxelRubini/2025-07-08/2/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/2/include/Queue.hpp b/exams/AxelRubini/2025-07-08/2/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/2/include/Random.hpp b/exams/AxelRubini/2025-07-08/2/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/2/include/Stat.hpp b/exams/AxelRubini/2025-07-08/2/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/2/main b/exams/AxelRubini/2025-07-08/2/main
new file mode 100755
index 0000000000000000000000000000000000000000..8550d446b31ade284b76e1dadc81411fa3f214c1
GIT binary patch
literal 43664
zcmeIb4R}=5wKsky$v_av85A@Xt%DuBiAu~Q0TKk9KnBjp1S1I;6dgh`At^~FCKCt>
z8k__<4x`v&>$O}<`?g+hYb*7lr4%vYBOq08w0@veO|{|~BM?y$zsUc$_TFdaWHMvX
z-v7Pt^SnJ8_StK%z4lsbuf6u#A2V}@(>*)MWRmnJS(+hH&XL6-4pFf2=i&v4L&}%Z
z@UK<6SQ>_W3WM=-2TxGSA4~G!G*!R}O!c;j^4Ro3fv2ZBhm=yiM9&scK~E(M$E12@
zdbQF&c&zN-NNSqL^LlEm$J%QY_%Z1NLLfag)+60mZ{zi>!NF-872;VhQoUXhU<BH_
zhDwo!2B#K6z@w+SK8Z*AD-rsPO&uts$HD%Uq}X~JMZMV6Ch+x?+MtJ0`fF{a+|bm@
zpb_;(`mFR_e-+h><xkH$L_Iy#`79Cj+HT<pvFTn>Pfw{0dagq~UBw*o_5TWUk>-o`
z67^rNXh2WNzUU!vHvY)g=FD3lCACSN1k=k+l8NO<07g%e$m`{VI|hH$9aMkP=<>@0
zEz54axbo<l)1PU_w?1Dm=gPX;rIYintgD(>SKH9iI<Yl>^2Et`S<Swz99FM@(Uqj(
zNDCj4l(sf=lH^BUoV~$BWmn;E2L7tPd}`P4j#ia5?Ho4Mz5m&s<@ax!cxhm(<Dm;1
zw>NdT$EAIC@`bal@1K5l-2114=f8g%RT4g5LEv-Zl+J*l@!%B@I3E0Iba*`Y|4D%V
zHz+C|eknRV9()%R91ng$0{Yh{!iQX!#F6*I1pH?v(8DftQapaH2km(9>;!a1z%RtZ
z-;;nJX9E2^lz`696VORbz|Z>$@TVlee<6XM?@Ykw#035IQ38B90Y9q~=>N3@_>U#9
z^AQQ!eK>(!S0|u<c>?|aHUa(F3GC$N1agf}0KYN;{P_g@j7^}2mlO2MKmz(X3FthY
zKrZsnR{X_22NUS?%LM#imO!7~3Fttqxb0q%0DdX~onZ;=;TP~@<E8T?>jo~Fl_yd=
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%0DC3pNA5eo2SJt~i7bRh>Ar2B-8lwxs)
zMI&^DrM5N=5~1anr;*%j(goiPJ!pP}*ijJ=VX=e`{u#3NlX51`0|20u-53HsBP+VJ
z6J<<B>QZVhXkLPftV@w)MaktF`R~R*v$ofwZE6|OAgyJgr>#1oPFr*>7Xy1hx)^-x
zMb6x8YXgW_+9=X3NVVhC05*wuKWt|Dhp-y)1JYE7y6+IB9k^hF(-e8rZuAJ19sm@)
zbRwZgzQ5DDdp+)G${jx)2mHVnvV7M=v~3;u0{ine(lolVV-{_uV+vV92PQqJY=6d%
z9haS~weFO36hfm>+NdXK3#k{-!4B$RVoNI%5L{Jmw^;$95(}l^iB?_o5Sv>>N@cJ?
zLY1_WFOX*2Z4M5k1jt1=<Ux&W<d{`b3TpXON(k(J1gw&}n;jP8mO3}WA7P)586jx$
z>Z{3suq?*%T2mOWk1|4Zbb78k_zQ+s*fz~(mD{)Q-C6|GfHN6_o0$xl1TF4RV`?$o
z##o9w`E-6<9Q0*ihotX2%#XU&uZn|rAXXUgE0NNIKDYY5BG3MF<Q~Km|HVRqbXVpZ
zuC-XN(LD&fK&rOY!;4f6!N3!sgY)cxmhCRuIj0Z6x`Xw&IB6t?5ydY<RB?hA;DVVu
zQxmbp7#>^58@e&@u?4t(7jpnkhf)AN_!qc?Ee>~R4GxL9GK#UPXiuU8xZq7CXh^<u
z4TPjKbwpv?n2KD1uV6j%uxpRt08(i|G|cFz^~$X7lq_bU^!W@Lzx~uTeEg=8?iFqI
z^K1-_#j%k6McT%Mqh)sl%<lulh7~RyD&)t4quv6D21yCBlrCZJ4StHqit+0Jj2?2y
z9B$r%YGf#<^r0=r?^dvi;nbBM8NXG0{APm#PD9WZ<Clv8iz5z63|xZ)o}Bp$8$R^S
zSh9%Jid4I@hc%FoV?})!gAE6Ybm~-%485FESQU9#QcMleRtSiz1|!(O{K5Iiu~D0k
zuIHn+n%-#CzAWP<$m(sj(RUr{qm~-bM=jA4?Xyw4g>;Wmi{NJ)6F_^2^#&A+A?36W
z*bn348F8|eu?5A8Ay+Pj90n|*8t#k}y;Pz{s9F|lfw}pUaPwxlqYP69?(fL$ACYjd
zGa`lf3S*1cQB(vt3rtGjEAmf-gj4#C-{A$J->~(Fc+};%m9xj%w+R6};vrbBJ5+;d
zz6Lww*gkWsHTiUPm+^WPKd<B;9w1g(ymbC^tX~dHCKh&bJwr-nF2=6DYPGF~S7rS}
zQQ=>nC7tc$Tl*pNb0C4s5Tqm0v{p})gXSz8gmKLVM_oqmI(0Hq-7rJui-`fFVFHb8
zOk43M45ET}{5Ht920T0UfDbRk#X{mDu#W|NZ%{0khByI{90ECQs^Bo2q=f{HTmtf;
ztnLM(+``It+P0woIEqzA`4r7#U_63DB9fK7JxS0=sc|X;^(DOOA-(EOs){-fki~?|
zzabK++J<tigtcrQ&D2hlMR3$8de=z{<*;T#<|L{L<+P$IJ%mORsJ7@JH6fxB-RFx)
zq~oqnc_BrBk<Wn09S%4#Z6oo9dApVIn5=|GrJcY9D2yS9>A>}h19JNU)aSS4)VJtD
zTu*owAkl!7WMk7YEUOb0x%iSU{!_$T$b2)?9AY>o8+j?AHVRr%zD`#QiZs_V#PUua
zp*_o0--7cc1(WV};o;f{(ZcvPcQN9lcC!TYGPsB|qpOgrAs)kF3M-;kNtFQ8qn*c^
z1Yoe1F0jCfJ;~!kTp*xuTMzv4;R80GvE>&JIl?cKu4$hMH%GMpB$8?}U2L&3-?$tj
z@uapI;IIn|O#Qy)E=+Fp;1=Fz?##ckv-(qJrJ!GKFTmu2D3)yt(&m*_k)4`i+NW&i
zRR)rkf_;iSM^n1q#l4Q>+SN=9Ai7}=<Vdg@rHQG8y2I4v!p?>gS_O|$;KKS+zUxX%
z0L7U1I;!zP-lPyb7N%mPAx?!}+-k2|J<)f$;V4E?&r*U4NL&Li)(Xed3F&S{igOR#
z09=9-QVhvfAmk{)RHfjvmgfl19hze*44g`p1C`*V@MLF--0=g15l$@3|0q9M;8;Hc
zz$E{#ooeSy`S)(q>FSxPd)R5J+xH;W&ESLSTM6A@jTzvJ4qzP@nwC|pejE<r<dNgC
zW4>S^T%XIq!WtZ*FpGX0oz4T}H<bMj^e{vpEx9w_mD{f-Gl3pI-A{eT&n9VPZ3hm!
zH$=gFCwc()w>uTJ)*_EKF=gF}W{cG$aKL@z`8u4m>9n{4-B!0+5B2QB2PQs}+ixPo
zU;}1^HMplaSy9(W#i3$sS$-w297BP`ez$s1yB_WLar<(s|D|BnR!*ltCECp>pnb~{
zTG_*@KpWk_iVtezsa8n0t6+hm&L{#(5SLF-dj<|hZ%tPM@14S>-a;(EGCwQ~^qyj!
za;F_TrIfRuEL1-Xbf?Y>ju|me9U~VNbT=IhpNmp`{mtxq8{g%|yj)Ip32w;ZySi!I
zB1=0iDA><!ANI%er<!0}urIosM#ik&0(?R(VX6(^i7*fAdH5rZ5h8zdJMJ|N_D9!z
z66=rh0g3vfr<b6ww8^00Quiq#crj|wr8+Sw-iBF}qWrBi{4p<=u&8(`Y~QVZPPcF0
z+DE;!2Djy$s6w}RoetN2rvj2vVYjmcpS$}+ZdXwqn<yD9v@CcB8(FM}MEokZ+u<f?
z{R*YjXdmn)rQnV3Z_+88yuJYC)I9q1wDv5@vA=TxhMJOjC^jyoZxyAubRkkVW|tB_
ztj3v5)M?uDfZtstFda?IM<#qVlp)5+W;O%6L-pW<N19}1@?G=|uRKca#89L=e;qea
z*o(keeU!z7-9;G#;7}|L;6kp#N<(g+1t#dMl1Gu77^+h6n%v&U3bwJ;35^h3-`T)|
zVfnmv9tdK)AfJ2?DItrnF}N5RtVUTxMwBs;KtBovLl4pJGZ^6EAS7*pn!@V|ieA*N
zC#8Y}pNJ86Zsuz~^>utAP5Ta0IWG;*#*9W=GQpMB!1F0uF)8W9af3Y*z2Sl$3ot2;
z-OK|}PVbpLoEa(&KgtyBfVaf98;?`NKV-0WvJy6}kh#+n?!*mlF&+`DrPy5RK;e34
zc6c*PT_2~k9ua$;^1bh(Kwp!b183CH8Ge@Gl6Nj#KWxxKBK$b?0lGyt6F4DNg{NSo
za{t3TKcYXH$X%IO*g+p)N!kAEU-1VHRq6UXS&<*>QMNDO52l^n=peF&ju*G1!z9c&
zyA@N9vLlMogBfSH5=wEf8-+aT*MO>Z?dHAGgA6%Xw#)MdwS0&u#rWFg!q)~xtzN=G
zm-Cb#nJ03$4**xV+e?HVjsDgd^|xyXGdO#&zg6IGvAudBratCxnNQN*?h@{(?+<Lg
zf!{UwIqrYo6gcp1-2XCPEIgcB#Ww6#3c`)^B}8K4W8kn3U}3qq=TZPSD7U{#lJ5}x
zf;+Kj_yBW>N+67l%Fl3*kGkogvO`S!7c1jmklTO5yx2BzW99^XR3mT<lApH9>+Yj6
z_KDEv>D)Dxw*nvJN>NOwH`3>)EcnNQnL8V^b~fG}{qpGfJ@V*ldgakG`w@Dyymqq7
z<j-Mz@Z&Qj(0e-4=b<sflw^L36t$DEX=PE=5=@4Ou~J;*BFF@k&=p-YsF~D(eYm1N
z;2()iXfUch+(|=9@D2@;{gB8O#ni8;x4>!F<|}HUBRmTx&iol|@-0Cv^5mFW;GMI>
zvoV>nC5{qk&5-<M?x4f!3f5#O1$|0%Kj8uwZOzkifY#TGpXR*`SJX02$$Uc*y9?*z
z1x&Qb8~y_W2~KhS&ydpoGHtKY?)hm=dXEfzpG)nbps9U1H4n`DL6?pLMz&$;D9P>g
z)x!AjY$}Z()W#<Nhd5?{<Zkt-=H3<I*^yxi-^*N45u_jF2aeI@sOiMd>NGT^zKOip
z-=`&=a#c;be;Gw8YnV86?9hoogr*{~i-OCuOlq3`%C%~=%4TIqeW5G!FXD(pzV{-S
zlzz-H62~0W*a(6JTGJuQ1ib2^xKu4X5qaTXXf9c20{fUtE|Tw}1<lj+tp(Z+v<2_;
zNA{Hl8vz#a7}iGN8=x{F2bkYTx`@mK2xcB-Ud$Ep+Yl?fuaz)e@tGp*feJ7#sXuDM
zOCxmnd_SAD$>w`(HASZUa4I{0qy2jd_j|z}J>gAJzs&9Dsv3;L<KUHa`X5h`vJ|e<
zKOr8A%<T6QMz9gqgnei?ZAy?yjbQkAqsWZS^YtXP+6B+81lEuqpJp+}zVLGdg1z&J
z?vUL62-qPNWTVDM^6h+2X2`TD=5N|DVl$$8D0~o-(Y&UZ4!a88kncPQLaxvn=&eu7
z2SYga!EP0OlK?*BfIBG^E@T4^x9L_}9Qt+@PKiob2rv(kR=6Dh1Pc&?t21T>-KH-o
z1pksk@bH+AiE%OK<H*jb1U|<;mmh4aJ%P^=*RRLx$=wL+KgSC&z9&DqfpHsnJ86BI
z+_4wnNUJ&}Y-Leg(4BG~%0x%^(<*BFX;>PbJ7~Vg!a@#Qik$K^!SLLHBeL)qyx5P1
zSJ72_8a)Si^d#S_5QLAOR5Iv%%JYtxjMm&Z=e!Caq|gr5N?vp|wjnT329F_pe3*sS
z>@ZQ$#{V(uIxco+z9T-MCEt5K(dQr1k~btFqaNzgE(X2S@RzVOgtXxd>Uex~AA&RA
z2rITmgI2?Q0f$N^M(!EG`tEdiWU$tB3ZL9-d52tj_yO2HElSA})(?wSY4{OnE)qJa
zZz<|9T(u6mlTRV&9)>l*yi^5up8|iyGT?xcx!=@-u%8xYcY08fmH;oRuLO4E;4Ni}
zTTQVS>~1<9E<zCv|2L4zzb{KZU9FbU+Kg{`>UI&Hh++sxjH%}Z%aXqY7R)CGYdEmj
zyg&vKXUF939lV?-d92xQvmwC<VLK+@MHgT@=`Df<NA-##wn3t=^g$Kp%?LnSi9Yn~
z0FmzRaUyKLB=ZlvfqrTr{<g(1#sdy$w7+1jP3j!HGtmABh-+5D!jf<15Cn8pX!`tA
z;G8WQ>!rpJoIcC$q3SU~J|@MMHJBGjOMDXC$qYnm7xmcEJ^rp;1w+9Eqx~367OU@K
zN7`SA4|l;4hz&9<7Wf9)B;dLN`>cI93fU9>H`br~!j%|7%-Ap`p9_p|696%*>o1rB
zb}|nYZ~N@9D7UcgjJtidouRN3hCZ$D_h@GgvjIBO+rWe{e?=V>9CaFr9Xd5^X6Yx1
zxL-@#HDoz$q|1=`!||k2pd#4O%0PBVH^?33)DV`GUNqAO%iqVoln4QYmWv9zmVgqi
zoz7z%#`bc@1*okZq%w66)!q~SHFMx%ixkEiyB+!*V<WO1x{I;MVqh8-+RdyT^Tn4i
zX|0q%0KTA#?u623CizT2_NzoTo<ru-R$hZ`idH-cP0|<5KrF2al*45_6W+tP93swK
z0*9vWAbt5!nFP9)OaL~V#=pyhNR1FOkm-f*MxDNQ2$OkLU@|Q-%L$<?sMj&&?0XB%
zFC{-XWUO?&MBvc$rPS<Atl53xgYh~151?wF3D($R2o3)^KJFS$b|jG<hAN0T`lb-0
zRw_UbU-txvxgkvWw|z`V1q`!pIG?!nGiB`w|B8{v)*@LIM(Aa@G|6_+l^_jI|JnKo
z`4IFFU4*@$k07QU_^7eJ3;(w5f*LVb{g{7;!6{m}gxN(EdOJe@yhfk-#~&`{)g6wy
ze)xO(IKKmddnd)^8~Jw_9L7y#`VND>12{#+)sw@2!o9j4x<!Qxbl>#*3}jzFYM)HO
ztvq~Pg7M1?^bho}AS(#o#kddtn7(TO;{^io?`9zOk43(b;jiKY{u4-UD#Fc^sANMv
z_y1%1B7^An8nCRQ@}@#}QB&2%_0kZ1@UJlVpVSAw+(GDreFsDEd}aS#bR(J`qwGUP
zU4mo3h^XpaRDBOBMZWVbpnuC7qxH{!{vXr;eRDO&&9%+^JI8&sQe#C^MZFilsnVR~
zZ}m%xR4mPtW=adC>!dQN313=X=jSDbR%w=1TH&qq`<kXs#n<rTHz(@w4db4QM*KiQ
z6<4P5w<e}qD}4?49`lw;`VMkyb(62&+R##0XRU3vHu(Hj_ER3B4=O7f2!yY7$M2z7
z@m=Lpr}CDpb@;6hZ<EzuQ_*0puW0o&<6F-&GDS5hCp%}-#Ox^(v-2kwwtDL(&Tm;-
z+fX|($37`Py8!3R<VFZrPkB98=ipRo<9SJX@L%cq!_|5UCyhsONC)OEtMB^tES4QO
ze)avYT&j)C8jUMU^z;{s^eU0!N)bJa94wJsj`WE|WnYXR;V_L$zG^RkI6RiN{B~gA
z6w=P$4GffHBI`zKLHA@mJ}^MvsCYlp11XZU3#kLsjAPrtzz4{8?i?8CrFu^d4CJAn
z1Kz(8Y4+0t1BZ}yBF#p9+OK#CX&bf|{iv7y>cD`N@R6=3_#xyG7Fb^!7+8#S3DQ=i
zTaa!-TJk#DLE4G*Y}7CLd|+S+QhLVlL^9nvUoy2?OykZTp1KjV34S5|4k1#$lyHiM
zTPU&N4`*o7mf!F;r8LXzwDfD_kt<W%q^mEu>atwhC4@)Fi}9EG3XY@*fX9lzM*Ouy
z?k1#CVVWh7G$+m4a8{b7C@s~AgB)si6aJQL9T<SB@D=RV07R6E@b@VG4xsK4q|(eZ
z%e_f6)6(xro}Fe5rOZsr*kCS9%U(CEFfBhYyeQ3)^h{bl0EKB8Gt;a<M1`4YsU#CU
zrdvzgOyc1`DaH=NI9+a%jbtoApWKTy<qmL<s`n%nrlqf=wgM@0)3TGiXQf#Ifdn90
zIFjj#<o)eq0|U#b-dxm6%MPThOTLHrC%UWgw;psKqVg$&=oad9SI42d4fwlsy2*p-
zDk!5R@m5^?nvT?<7l<87aYpn~M0%N%R+6;sthD^1wCtk6ih=Tp7TIk(c)Wn@BdTLY
zYlw~;lT9h{l#HtR_*)EG<uAhq@lLct)L$EtooUu}Dd?7f8C<M9D=h=ULzTRL$Oh7Z
zPG4%b6LoW_F0+%mG^~SI**28*qKpkrR<??j5&u0XOM%U8rFyL2oN4KyWbnU%+FVCA
z5*U`W0?ihsSy9HDy=G(y<0E1x8K{0CR9ypF*AcDRX_j?KMQQ1QWEgA<>-oa8RAo;$
zYz4*TXqWEX-gPnBUyhCdU16W`bT=ohb5yc#Bzj_~iOz-!*!bCu_O(w22F8OnJ=9Jo
z$p?S%e{iOo^3IvGla$<GinIg!jfe=V<zsRT+S!NkOwKsvA<#_gObQHNH*AABlyXn<
zy-CzAUCnXB23MdHQts5-okQa<zI?q`B-cmV1<ufRH-P2}v`e34N%<+Y+k1tvT{H`S
zZ=%1{^T*GWZh}J?lK;tHOr}4Z{$w&gKSTP$WPWeDv@R*{_;l%&Wb;pFNIx-~znCih
za=7{AH0k%l&8MeHpA0wenJ&GPYJO^}bogv@V7hcT&3tmIbTrNUhZ)jSviWDzq(6<x
zMcuc@n*V)<>5=ozFHMs+r$3j3g0IGzADkgQc#-+zY0^6v%>jw_OX!}{u1m~l@}*16
z&rXvboIoUcCYU!)k-oar{7k;|MW*?WQ%ygccvmtiJT`@jpPUL=KAdXaG)>w+jR3o*
zQ{A_x6I=JsAeztzmw)7I$w2;Hn)xRaNc@!HmoPQd2a?RsTcjT*nY%60=45)`o@{>D
zA{}S%YKr-{7U`)Jg1?$#e$pasFw^_PX7etK^g4S#X*R!Uk$y9b;QNP}k6ENI+4}>-
z%||TK;nV}eQ1H0C<P{5RSOFX47A*K9?&x<;=^+^X{qy;!2L5l+KsG++NKbDTPyhMv
zKQ-{bsR8cICH5OW#D|`z-xM<DYhv>Bn?m$pM}R+8p5THxdp@q`>32k4|D7IOMQ0Di
zO!VN&Hhc8n>(S$2z5J8Y13p6N!JJGFTs?app<8@-aM^=B*}~Bau=HK=La_ur6uZ$g
zmM4*a1zAa>pc;<|X`}}Py)hije*2nUX<bE6svwB{9riSy$5Wl}2ZSPpnj-DvyoAXE
zY=(;UAIp~r#<2cld41l(m#(pVw_xNmk=Oa=t^UvdyEPQQ&B;~{pDogbBCQtb3X!f8
z>5oMEut=X2X}3sU5$O?;o)qb@@e+H^6X~TQoh;JXB3&rbYLTuG={k}ANTd&o^huF+
zi}V$d9uetDkq$$!L(h34y;P)=MLJug3q@Kj(iI|IC(<8@^kI=cDbj9{z9P~iB0VY6
zVc!$&i}X^FP8KOI#qT-Yr@!$Ozq>Zont=!@(`uiDUtP0XvBNPr+n$Z9qhI%!P?#cp
zI1r0N_HB~Rm0DYQiB%xbequa)8sACyeK5zB9FeWJ@p`ik7yRqv{FegWDe&1E8?YQO
zM0B=hBZKE&o=86y@Y#aSG66RwiFWNAKx<ukDh2$vG57}syi?(LYz>Ro<;k2*ub{)$
zqkyMjz!E=WZ5%(7CsL7s&k%50Q_wRH@Ob*ULEtyW#0QH7d`k@6C*ZO1L<is|X`Hl0
z^uK6Ux{txfO1i)0+~9ZN1RXs-(cya;{+P(`tm*J~0FTH2QHDQS`r8T}Gn&T3{{r|F
zxwqXC#iO@07=Q`hHrCIa&*0yQ_-nn^M8L819P&5;r{90>S<Z{}HEVAI{I3MQbuP!>
zDkv_*L=%txF94_Csn&n5%_{I;Nq~PO0o*n`KK=QCTQE!N{V2#wixS{(N&x>)z~lWc
z_uaB2SwVljuoInr5@x4(@{VV4%<{O%PY<p4>7m15(zC<O^R(YU&u;-Ajo%w&8*Iq4
z?ne4l0{X8rI#hG;^GO2yR5+k`e2z;1U(Vp8q|OPPKJ6RO)0hDN!36N%06seDf+7BO
zM*@5;0sITV<NYpr9^#krp#OmA7r~}f0(d-mzn=j9a02*$5j-hP(&IF)1xb220se^u
za5Dm|c>J6XIN3w&@4DwCz`ql4(u4kcg;v4PJusbf$gYInyHvnm5cvA<7}8!4JtGj1
z#^YyP0(f=;`1cdQA5H-OI00P7P&p?F%vu?Hk$=VlPWBT!uE!I81S|ToCIS363E(dz
zfX_;cPyYeHslTLac$;i*6t8b4z`qjxLin+May{VWuVVel{R}=%dL+irJSgaF5$)y(
zkzWNoo*q6<0RJvFf8ya!NdRvG++vs?bxq$6IN728JD6>v;E4oujwgVR8y%mYnShht
zdggM%*9rO|0gu(g!31>PO#nAT3Gwt$3}C$e{UP91!Gke*ECHSF1n@!xd?*_7(C@m&
zgVQfqS%+Zb*BTPQ?*p9rMgJXAz3wvtuKx~co1i%c>m`!6SJ)NXlSkQgfXCyfE&*IB
zt!(n!vwZl;<BFxV9)HC$iGC$HtFp0?{X%mdPA2PI-}HCLvuc~0DzfP3(@XvT5QVHt
zUtJabIyZj9Jo59^F5{15=NL~+<1xyAu-XYm8Y^m>Tysk&dGJ5-_H0k7w+_d#_GZ7U
zG@n3ub>8M?7b~t{AZH$aD7p&2xjw}cm1*AGNu^GA?Na-s68-EKFU{Vjf@NNRk*{TG
zo!2>k?zdsG>VLA4sBRO8Ga2Hz8vNf<mfACr<-ezeh#>z<Hj<Nv!+hw<Q`-O|@OxSs
zYHw-rdK!Jrv4-=%#9%)7^EOp9dz~dP`&`fbr5=Bi*XwEURe7128@h_yLVi<ALveF$
zeY3Nws<yVOwrc*oQjdMo{ECJuU;P|!1E}E^gOh8XI}94A@Fh#V%W4}+;ZUl)O?Yj_
z#R!kT-cwoUYw+U7+&xu3&$2q-(uz7y6(}@&Dq32lN?(0r9j;JRk;{mOK|j}C>#1mJ
zs#xXmHu#%XN!4`e!c)~!Ur)c*Zpfh%YW;&y!4#YrvE=d0o?lq(^f>1gc|6Ero515#
z1W+lOFL{a<%_}T+&5}HG+}F-5bbGFyJ-gId<|!+j>2{*V4f9HUxs5G;XQhMvusi=r
zb_Vz7<ksU3h_|7^>+!GTa(f$~3$Lr*U7wrdbk|SL$-}?71ykr>JO0U;G<iy1e(q%Z
zBxLLa$;&CoE0{bbr+^@YmoqtcazRf1<h*P`A!uH9PR^9v>?xCoq&=VgW6#OU&CQvV
z>vY=f%oZCwP3S7;3J5v)m+U#;;s@zT9{*&1PsCN~`F4I4juP(F2{#KT>2wz5P^<9!
zIRz0r6XOCL;m!-XzM`ShyOc~Z;?kKZdf>{vrP-eOrJfk|mMtvx7jQ>k>uZkZ<(-3S
zG}kr^71W-~DOA_id6%|S$E7j}c8X!LVh}Yx{n&Fn#9(bDjIqw^s&r1NZT9$Zb0-$t
zTUFt&;5K2;6HHg*8jrW4K5m;u_E-wkE%^|XDP$HD8pBT6LgVD3D+W!}HY`irkeCRK
zw6b#SoY6>Y)O|(_D*i?;AzESR^oXlc&EDD2-nX1mB#-M_5AHVAHh5Z^y@(4um8}&X
z=5aig75>T^$E@=5!kI3QJu6of!f{m8;l>k}N!UGfROcORA@$z+%KFAZSZs7mp*C9W
zcKbKea%`WHqRCA{I~W<+9*@7K$+yx2E|&RgXo&inO6CrBD&VNu>mSUKr>fcK!9}jB
zIxnY`r&FqJV7I~G_?ETQ!$rnY!-%N#H4mnC0}U(tByOVIZW4_PUQxKaqU*DoywzDA
z&$8B5Pa~Y3k96!`<yk=yA6(?5>bjQZnjwZXXuyM?CNJZ35SXSUX7+<xB(2#CbXn_s
z%P<P#DveDP==!?arIoOh3e3i&_K4iMc@hN0-Mt7TCu@>Ko!_`B0<!0k7>GD0Rr*&o
z(ooOGthKVX3S+&JNr*`_>IxF+ERQ({bOd<M^|&ycuZ6d$hk!A%m6iRs4rkV@XX1Eb
z*l1W;9|NhXD_K!*7*kmVXD<D$p<ZoJM^|~jQU60jx-<2CoijzVe_!Kd8I{XDl{L#f
z)fKgMk&Z{dQ}h7)DJ!0(M+szllRX|EA0Q&ei|feeQ%7^V5ZEq+4%t{(O!kz_EzR|a
zmiRE@$~0OTtfZKm8DnGc_{p-9tLD6L=drY+3SO_-AM3A6{Y`PFNbdg)Od?2OlagR^
ziU&cSKjQEPFRV)QXw_6^#|&>YlE?%SsTOr7n2Zt(4bI6FNZY)sq0(7WSwG0~h7ujj
zOPtjxr#Q>*f|i|R0rN@U+*)<dogi??qb_HGag=pT)tq(6YZR9g{O^vKFj8Q06g6;{
zB_YOTi(W%-M0xvrY83$(x^glu7gyAIW9K4fM$tLQ*W&m1swrMv=8c^-_ypVJWd>((
z1Y8eiG$4nz?pfO0tP9Ggpfhl$Lwi9VYF`)54Q-sJU%MV!(KOLi(X@&Uw?V@wD>sM9
z=qrGc^6=GF<-~H%S2id%WrLVjbwyqbCf_PoN#Y@t&}^N~6=fa-&s?kDVkD86BHn@J
z#0!On&eTJC^Y083M8@8VCfYX1VRISgGe54H5ABx-|7SXAb7BXrtE|`)T|L4T)7r7D
z0^2H*XF<bCY{+=#<6eC|8lN@GlPmU_reFnLN6W2*dj7{<AH1MZ;E1CdvNjlMc%EhT
zz6KGJpr=VjeSJJw!W+uUpyY2ce-B<2oVmjo<l!PBMY{3K2^D2CGpud)Rp#VERK!`)
zxivSRo40UEL&5_ot9ezuzhWs;RAgz5{)SIBc(ax@v}83lA*O2buadGNprtLfbyX8<
ztE8;j2JAI7N(`~4qPa%Os#?_mqCE9C@sbsYSMh0zK^YIqn!I%tR6)Eo*7=Ddf`Kf*
z7a!}$q8$j7`Pkwv%UdJ%9BQgiSI>cHB?8mdN^hedTd8EQoKdVvCeqd_qsTWWI7R)P
zs1gfkfU#RqUt0-kJ~WJfvKTkKWjId>+b;DKI*YyFe<Y#%N;o==+zX=b+M`EL9V{39
zM?a_2A#`kItiMsz*HfF0C{q1=R0kL0#e_dxM_|u3QD0B>`%<Eq;p*>{y6|@rcZT%(
zJ)*vzE*8i*_GV8k|D}N9^eWQ6e$Prz>2t&MP(pm__4WH!Hv&dY>h0_Iw)9lLrv()D
z5Dnu~i45I|((89)pPn8)y_;tv_ri2MJ#9oe-Lca1`aLT>wTcFbf6~3qzaT5!A>ev_
z{hpVe>i4{2^{30PiuyAJLH*vCp6d6^s6O45)7#hU{}3=@QK(sxtjN$~W&h#?Yw#0m
zKlh;6Sl?>p_>olDgH8p<S?tl%e?`t%-|;<OuBX2f=PMj4Ne=x*q(4P!tgoLp>nTng
z2R*U;|5DV~^{?L}(9<>|Zg_OQb<l6{LMVED{ho=Q?$r@R8r%LKW9lnS98piV#8lAx
zPba%CroJZb#po%0rpfrkkdt0Tq0xWn_pJ2PYOIX+*!u4Rh9g`y1_@QahiScya#4HZ
zxoBRO<3kkS$Td=5zc-X|hV{QfT@q0@GyR@Swy58xcMNdo(c9%YNjeLa$@ca7`hB3S
zYd8jdE{Gm|eCYLcJ2)5hjqP{d%kevDVB^W)N#tL>zMiJX)YtEcYNGxYB5ru}dU`rO
zroMhIzJ4vQq>po*gkDe2{|o99OqXB3FR(?_kHrW2pyvtz2$nqviqFZ3`r~5YdVOOW
z(?zUCr>JkC$pH^Ot0rB9Kb;?4E*$?xc*kqx>Dj<vRpHO|0=->5k7Mq*^%wn&V@!&v
I5R;YuKdS6RhyVZp

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-07-08/2/main.cpp b/exams/AxelRubini/2025-07-08/2/main.cpp
new file mode 100644
index 0000000..d073216
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/main.cpp
@@ -0,0 +1,123 @@
+#include "include/Geometry.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct UV {
+    Point2D pos;
+    Point2D target;
+};
+
+double runMsims(
+    double A,
+    double H,
+    int M,
+    int N,
+    double V,
+    int Q,
+    double T,
+    RandomGenerator &rng
+) {
+    double totalRate = 0;
+    for (int m = 0; m < M; ++m) {
+        std::vector<UV> vehicles(N);
+        for (int i = 0; i < N; ++i) {
+            vehicles[i].pos = {
+                rng.uniform(-50.0, 50.0), rng.uniform(-50.0, 50.0)
+            };
+            double targetVal = -50.0 + 100.0 * (double)i / (N - 1);
+            if (N == 1)
+                targetVal = -50.0;
+            vehicles[i].target = {targetVal, targetVal};
+        }
+
+        long long collisions = 0;
+        double time = 0.0;
+        while (time < H - 1e-9) {
+            std::vector<double> bestThetas(N);
+            for (int i = 0; i < N; ++i) {
+                double minFi = 1e18;
+                double bestTheta = 0;
+                for (int q = 0; q < Q; ++q) {
+                    double theta = (double)q / Q * 2.0 * M_PI;
+                    double px = vehicles[i].pos.x + T * V * std::sin(theta);
+                    double py = vehicles[i].pos.y + T * V * std::cos(theta);
+                    double t1 = std::pow(px - vehicles[i].target.x, 2) +
+                                std::pow(py - vehicles[i].target.y, 2);
+                    double t2 = 0;
+                    for (int j = 0; j < N; ++j) {
+                        if (i == j)
+                            continue;
+                        t2 += std::pow(vehicles[j].pos.x - px, 2) +
+                              std::pow(vehicles[j].pos.y - py, 2);
+                    }
+                    double fi = A * t1 - (1.0 - A) * t2;
+                    if (fi < minFi) {
+                        minFi = fi;
+                        bestTheta = theta;
+                    }
+                }
+                bestThetas[i] = bestTheta;
+            }
+            double noise = M_PI / Q;
+            for (int i = 0; i < N; ++i) {
+                vehicles[i].pos.x +=
+                    T * V *
+                    std::sin(bestThetas[i] + rng.uniform(-noise, noise));
+                vehicles[i].pos.y +=
+                    T * V *
+                    std::cos(bestThetas[i] + rng.uniform(-noise, noise));
+            }
+            time += T;
+            for (int i = 0; i < N; ++i) {
+                for (int j = i + 1; j < N; ++j) {
+                    if (vehicles[i].pos.distanceTo(vehicles[j].pos) <= 0.1)
+                        collisions++;
+                }
+            }
+        }
+        totalRate += (double)collisions / H;
+    }
+    return totalRate / M;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double H = parser.getDouble("H");
+    int M = parser.getInt("M");
+    int N = parser.getInt("N");
+    int B = parser.getInt("B");
+    double V = parser.getDouble("V");
+    int Q = parser.getInt("Q");
+    double T = parser.getDouble("T");
+
+    double bestA = 0, minC = 1e18;
+    for (int i = 0; i < B; ++i) {
+        double A = rng.uniform(0.0, 1.0);
+        double C = SELib::runMsims(A, H, M, N, V, Q, T, rng);
+        if (C < minC) {
+            minC = C;
+            bestA = A;
+        }
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-07-08-Axel-Rubini-2158099" << std::endl;
+    outFile << "A " << bestA << std::endl;
+    outFile << "C " << minC << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-07-08/2/parameters.txt b/exams/AxelRubini/2025-07-08/2/parameters.txt
new file mode 100644
index 0000000..41a371c
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/parameters.txt
@@ -0,0 +1,7 @@
+H 1000
+M 1
+N 100
+B 10
+V 0.1
+Q 30
+T 1
diff --git a/exams/AxelRubini/2025-07-08/2/results.txt b/exams/AxelRubini/2025-07-08/2/results.txt
new file mode 100644
index 0000000..8ce59c6
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/2/results.txt
@@ -0,0 +1,3 @@
+2025-07-08-Axel-Rubini-2158099
+A 0.592845
+C 0
diff --git a/exams/AxelRubini/2025-07-08/3/Makefile b/exams/AxelRubini/2025-07-08/3/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-07-08/3/include/DES.hpp b/exams/AxelRubini/2025-07-08/3/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/3/include/Decision.hpp b/exams/AxelRubini/2025-07-08/3/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/3/include/Dynamics.hpp b/exams/AxelRubini/2025-07-08/3/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/3/include/Geometry.hpp b/exams/AxelRubini/2025-07-08/3/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/3/include/IO.hpp b/exams/AxelRubini/2025-07-08/3/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/3/include/Inventory.hpp b/exams/AxelRubini/2025-07-08/3/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/3/include/Queue.hpp b/exams/AxelRubini/2025-07-08/3/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/3/include/Random.hpp b/exams/AxelRubini/2025-07-08/3/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/3/include/Stat.hpp b/exams/AxelRubini/2025-07-08/3/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/3/main b/exams/AxelRubini/2025-07-08/3/main
new file mode 100755
index 0000000000000000000000000000000000000000..4da47c47390c8becc0af8829fd01c8c9dd2ad438
GIT binary patch
literal 44192
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-07-08/3/main.cpp b/exams/AxelRubini/2025-07-08/3/main.cpp
new file mode 100644
index 0000000..362c992
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/main.cpp
@@ -0,0 +1,127 @@
+#include "include/DES.hpp"
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Server {
+    std::vector<int> inventory;
+    double busyUntil;
+};
+
+struct Event {
+    double time;
+    int type;
+    int serverIdx;
+    int productId;
+    int status;
+
+    Event(double t, int tp, int sIdx, int pId, int st)
+        : time(t), type(tp), serverIdx(sIdx), productId(pId), status(st) {}
+
+    bool operator>(const Event &other) const { return time > other.time; }
+};
+
+double runOneSim(
+    int H,
+    double T,
+    int N,
+    double A,
+    double B,
+    double p,
+    int S,
+    double F,
+    double G,
+    int K,
+    int Q,
+    RandomGenerator &rng
+) {
+    std::priority_queue<Event, std::vector<Event>, std::greater<Event>> eq;
+    std::vector<Server> servers(S);
+    for (int i = 0; i < S; ++i) {
+        servers[i].inventory.assign(N + 1, 0);
+        for (int j = 1; j <= N; ++j)
+            servers[i].inventory[j] = rng.uniformInt(1, K);
+        servers[i].busyUntil = 0;
+    }
+
+    eq.push(Event(0.0, 0, 0, 0, 0));
+
+    long long failedSales = 0;
+
+    while (!eq.empty()) {
+        Event e = eq.top();
+        eq.pop();
+        if (e.time > (double)H)
+            break;
+
+        if (e.type == 0) { // Customer Request
+            int sIdx = rng.uniformInt(0, S - 1);
+            int pId = rng.uniformInt(1, N);
+
+            double serviceTime = F;
+            int status = 0;
+            if (servers[sIdx].inventory[pId] > 0) {
+                servers[sIdx].inventory[pId]--;
+                status = 1;
+            } else {
+                status = 0;
+                if (rng.bernoulli(p)) {
+                    servers[sIdx].inventory[pId] += Q;
+                    serviceTime = G;
+                }
+            }
+
+            double finishTime =
+                std::max(e.time, servers[sIdx].busyUntil) + serviceTime;
+            servers[sIdx].busyUntil = finishTime;
+
+            eq.push(Event(finishTime, 1, sIdx, pId, status));
+            eq.push(Event(e.time + rng.uniform(A, B), 0, 0, 0, 0));
+        } else if (e.type == 1) { // Server Finish
+            if (e.status == 0)
+                failedSales++;
+        }
+    }
+
+    return (double)failedSales / H;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    int H = (int)parser.getDouble("H");
+    double T = parser.getDouble("T");
+    int M = parser.getInt("M");
+    int N = parser.getInt("N");
+    double A = parser.getDouble("A");
+    double B = parser.getDouble("B");
+    double p = parser.getDouble("p");
+    int S = parser.getInt("S");
+    double F = parser.getDouble("F");
+    double G = parser.getDouble("G");
+    int K = parser.getInt("K", 10);
+    int Q = parser.getInt("Q", 10);
+
+    double totalRate = 0;
+    for (int i = 0; i < M; ++i)
+        totalRate += SELib::runOneSim(H, T, N, A, B, p, S, F, G, K, Q, rng);
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-07-08-Axel-Rubini-2158099" << std::endl;
+    outFile << "V " << totalRate / M << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-07-08/3/parameters.txt b/exams/AxelRubini/2025-07-08/3/parameters.txt
new file mode 100644
index 0000000..743fd93
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/parameters.txt
@@ -0,0 +1,12 @@
+H 1000
+T 1
+M 100
+N 10
+A 5.0
+B 10.00
+p 1.0
+S 10
+F 2
+G 5
+K 100
+Q 10
diff --git a/exams/AxelRubini/2025-07-08/3/results.txt b/exams/AxelRubini/2025-07-08/3/results.txt
new file mode 100644
index 0000000..fde4d32
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/3/results.txt
@@ -0,0 +1,2 @@
+2025-07-08-Axel-Rubini-2158099
+V 0.00061
diff --git a/exams/AxelRubini/2025-07-08/4/Makefile b/exams/AxelRubini/2025-07-08/4/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-07-08/4/include/DES.hpp b/exams/AxelRubini/2025-07-08/4/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/4/include/Decision.hpp b/exams/AxelRubini/2025-07-08/4/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/4/include/Dynamics.hpp b/exams/AxelRubini/2025-07-08/4/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/4/include/Geometry.hpp b/exams/AxelRubini/2025-07-08/4/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/4/include/IO.hpp b/exams/AxelRubini/2025-07-08/4/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/4/include/Inventory.hpp b/exams/AxelRubini/2025-07-08/4/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/4/include/Queue.hpp b/exams/AxelRubini/2025-07-08/4/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/4/include/Random.hpp b/exams/AxelRubini/2025-07-08/4/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/4/include/Stat.hpp b/exams/AxelRubini/2025-07-08/4/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/4/main b/exams/AxelRubini/2025-07-08/4/main
new file mode 100755
index 0000000000000000000000000000000000000000..5d30daec48a546ee61a42d6ddd6fd8c844edfb6c
GIT binary patch
literal 48536
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
QhE<zoYU+pzBa+(x2T^=)#sB~S

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-07-08/4/main.cpp b/exams/AxelRubini/2025-07-08/4/main.cpp
new file mode 100644
index 0000000..dba4638
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/main.cpp
@@ -0,0 +1,137 @@
+#include "include/DES.hpp"
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Server {
+    std::vector<int> inventory;
+    double busyUntil;
+};
+
+struct Event {
+    double time;
+    int type;
+    int serverIdx;
+    int productId;
+    int status;
+
+    Event(double t, int tp, int sIdx, int pId, int st)
+        : time(t), type(tp), serverIdx(sIdx), productId(pId), status(st) {}
+
+    bool operator>(const Event &other) const { return time > other.time; }
+};
+
+double runOneSim(
+    int H,
+    double T,
+    int N,
+    double A,
+    double B,
+    double p,
+    int S,
+    double F,
+    double G,
+    int K,
+    int Q,
+    double &W
+) {
+    RandomGenerator rng; // No seed for Monte Carlo variability
+    std::priority_queue<Event, std::vector<Event>, std::greater<Event>> eq;
+    std::vector<Server> servers(S);
+    for (int i = 0; i < S; ++i) {
+        servers[i].inventory.assign(N + 1, 0);
+        for (int j = 1; j <= N; ++j)
+            servers[i].inventory[j] = rng.uniformInt(0, K);
+        servers[i].busyUntil = 0;
+    }
+
+    eq.push(Event(0.0, 0, 0, 0, 0));
+
+    long long failedSales = 0;
+    long long totalSent = 0;
+    long long totalReceived = 0;
+
+    while (!eq.empty()) {
+        Event e = eq.top();
+        eq.pop();
+        if (e.time > (double)H)
+            break;
+
+        if (e.type == 0) { // Customer Request
+            int sIdx = rng.uniformInt(0, S - 1);
+            int pId = rng.uniformInt(1, N);
+
+            double serviceTime = F;
+            int status = 0;
+            if (servers[sIdx].inventory[pId] > 0) {
+                servers[sIdx].inventory[pId]--;
+                status = 1;
+            } else {
+                status = 0;
+                if (rng.bernoulli(p)) {
+                    servers[sIdx].inventory[pId] += Q;
+                    serviceTime = G;
+                }
+            }
+
+            double finishTime =
+                std::max(e.time, servers[sIdx].busyUntil) + serviceTime;
+            servers[sIdx].busyUntil = finishTime;
+
+            totalSent++;
+            eq.push(Event(finishTime, 1, sIdx, pId, status));
+            eq.push(Event(e.time + rng.uniform(A, B), 0, 0, 0, 0));
+        } else if (e.type == 1) { // Server Finish
+            totalReceived++;
+            if (e.status == 0)
+                failedSales++;
+        }
+    }
+
+    W = (totalSent == 0) ? 1.0 : (double)totalReceived / totalSent;
+    return (double)failedSales / H;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    int H = (int)parser.getDouble("H");
+    double T = parser.getDouble("T");
+    int M = parser.getInt("M");
+    int N = parser.getInt("N");
+    double A = parser.getDouble("A");
+    double B = parser.getDouble("B");
+    double p = parser.getDouble("p");
+    int S = parser.getInt("S");
+    double F = parser.getDouble("F");
+    double G = parser.getDouble("G");
+    int K = parser.getInt("K", 10);
+    int Q = parser.getInt("Q", 10);
+
+    double totalV = 0, totalW = 0;
+    for (int i = 0; i < M; ++i) {
+        double w;
+        totalV += SELib::runOneSim(H, T, N, A, B, p, S, F, G, K, Q, w);
+        totalW += w;
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-07-08-Axel-Rubini-2158099" << std::endl;
+    outFile << "V " << totalV / M << std::endl;
+    outFile << "W " << totalW / M << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-07-08/4/parameters.txt b/exams/AxelRubini/2025-07-08/4/parameters.txt
new file mode 100644
index 0000000..7d74d68
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/parameters.txt
@@ -0,0 +1,12 @@
+H 1000
+T 1
+M 100
+N 10
+A 5.0
+B 10.00
+p 1
+S 10
+F 2
+G 10
+K 100
+Q 10
diff --git a/exams/AxelRubini/2025-07-08/4/results.txt b/exams/AxelRubini/2025-07-08/4/results.txt
new file mode 100644
index 0000000..1dde52e
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/4/results.txt
@@ -0,0 +1,3 @@
+2025-07-08-Axel-Rubini-2158099
+V 0.00147
+W 0.998429
diff --git a/exams/AxelRubini/2025-07-08/5/Makefile b/exams/AxelRubini/2025-07-08/5/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-07-08/5/include/DES.hpp b/exams/AxelRubini/2025-07-08/5/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/5/include/Decision.hpp b/exams/AxelRubini/2025-07-08/5/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/5/include/Dynamics.hpp b/exams/AxelRubini/2025-07-08/5/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/5/include/Geometry.hpp b/exams/AxelRubini/2025-07-08/5/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/5/include/IO.hpp b/exams/AxelRubini/2025-07-08/5/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/5/include/Inventory.hpp b/exams/AxelRubini/2025-07-08/5/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/5/include/Queue.hpp b/exams/AxelRubini/2025-07-08/5/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/5/include/Random.hpp b/exams/AxelRubini/2025-07-08/5/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/5/include/Stat.hpp b/exams/AxelRubini/2025-07-08/5/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-07-08/5/main b/exams/AxelRubini/2025-07-08/5/main
new file mode 100755
index 0000000000000000000000000000000000000000..5f7b684d75bf43c70673c0a54a43968cf0decc25
GIT binary patch
literal 48288
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-07-08/5/main.cpp b/exams/AxelRubini/2025-07-08/5/main.cpp
new file mode 100644
index 0000000..139a866
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/main.cpp
@@ -0,0 +1,135 @@
+#include "include/DES.hpp"
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Server {
+    std::vector<int> inventory;
+    double busyUntil;
+};
+
+struct Event {
+    double time;
+    int type;
+    int serverIdx;
+    int productId;
+    int status;
+
+    Event(double t, int tp, int sIdx, int pId, int st)
+        : time(t), type(tp), serverIdx(sIdx), productId(pId), status(st) {}
+
+    bool operator>(const Event &other) const { return time > other.time; }
+};
+
+struct Result {
+    double V, W;
+};
+
+Result runMsims(
+    double p,
+    int H,
+    double T,
+    int M,
+    int N,
+    double A,
+    double B,
+    int S,
+    double F,
+    double G,
+    int K,
+    int Q,
+    RandomGenerator &rng
+) {
+    double sumV = 0, sumW = 0;
+    for (int m = 0; m < M; ++m) {
+        std::priority_queue<Event, std::vector<Event>, std::greater<Event>> eq;
+        std::vector<Server> servers(S);
+        for (int i = 0; i < S; ++i) {
+            servers[i].inventory.assign(N + 1, 0);
+            for (int j = 1; j <= N; ++j)
+                servers[i].inventory[j] = rng.uniformInt(0, K);
+            servers[i].busyUntil = 0;
+        }
+        eq.push(Event(0.0, 0, 0, 0, 0));
+        long long failed = 0, sent = 0, received = 0;
+        while (!eq.empty()) {
+            Event e = eq.top();
+            eq.pop();
+            if (e.time > (double)H)
+                break;
+            if (e.type == 0) {
+                int sIdx = rng.uniformInt(0, S - 1), pId = rng.uniformInt(1, N);
+                double st = F;
+                int status = 0;
+                if (servers[sIdx].inventory[pId] > 0) {
+                    servers[sIdx].inventory[pId]--;
+                    status = 1;
+                } else {
+                    status = 0;
+                    if (rng.bernoulli(p)) {
+                        servers[sIdx].inventory[pId] += Q;
+                        st = G;
+                    }
+                }
+                double finish = std::max(e.time, servers[sIdx].busyUntil) + st;
+                servers[sIdx].busyUntil = finish;
+                sent++;
+                eq.push(Event(finish, 1, sIdx, pId, status));
+                eq.push(Event(e.time + rng.uniform(A, B), 0, 0, 0, 0));
+            } else {
+                received++;
+                if (e.status == 0)
+                    failed++;
+            }
+        }
+        sumV += (double)failed / H;
+        sumW += (sent == 0) ? 1.0 : (double)received / sent;
+    }
+    return {sumV / M, sumW / M};
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    int H = (int)parser.getDouble("H"), M = parser.getInt("M"),
+        N = parser.getInt("N"), S = parser.getInt("S");
+    double T = parser.getDouble("T"), A = parser.getDouble("A"),
+           B = parser.getDouble("B");
+    int R_budget = parser.getInt("R", 50);
+    double F = parser.getDouble("F"), G = parser.getDouble("G");
+    int K = parser.getInt("K", 10), Q = parser.getInt("Q", 10);
+
+    double bestP = 0, bestW = -1.0;
+    SELib::Result bestRes = {0, 0};
+
+    for (int i = 0; i < R_budget; ++i) {
+        double p = rng.uniform(0.0, 1.0);
+        auto res = SELib::runMsims(p, H, T, M, N, A, B, S, F, G, K, Q, rng);
+        if (res.W > bestW) {
+            bestW = res.W;
+            bestP = p;
+            bestRes = res;
+        }
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-07-08-Axel-Rubini-2158099" << std::endl;
+    outFile << "P " << bestP << std::endl;
+    outFile << "V " << bestRes.V << std::endl;
+    outFile << "W " << bestRes.W << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-07-08/5/parameters.txt b/exams/AxelRubini/2025-07-08/5/parameters.txt
new file mode 100644
index 0000000..15e6c00
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/parameters.txt
@@ -0,0 +1,12 @@
+H 1000
+T 1
+M 100
+N 10
+A 5.0
+B 10.00
+R 50
+S 10
+F 5
+G 6
+K 10
+Q 10
diff --git a/exams/AxelRubini/2025-07-08/5/results.txt b/exams/AxelRubini/2025-07-08/5/results.txt
new file mode 100644
index 0000000..96994a2
--- /dev/null
+++ b/exams/AxelRubini/2025-07-08/5/results.txt
@@ -0,0 +1,4 @@
+2025-07-08-Axel-Rubini-2158099
+P 0.0423751
+V 0.02019
+W 0.99605
diff --git a/exams/AxelRubini/2025-09-08/1/Makefile b/exams/AxelRubini/2025-09-08/1/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-09-08/1/include/DES.hpp b/exams/AxelRubini/2025-09-08/1/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/1/include/Decision.hpp b/exams/AxelRubini/2025-09-08/1/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/1/include/Dynamics.hpp b/exams/AxelRubini/2025-09-08/1/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/1/include/Geometry.hpp b/exams/AxelRubini/2025-09-08/1/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/1/include/IO.hpp b/exams/AxelRubini/2025-09-08/1/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/1/include/Inventory.hpp b/exams/AxelRubini/2025-09-08/1/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/1/include/Queue.hpp b/exams/AxelRubini/2025-09-08/1/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/1/include/Random.hpp b/exams/AxelRubini/2025-09-08/1/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/1/include/Stat.hpp b/exams/AxelRubini/2025-09-08/1/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/1/main b/exams/AxelRubini/2025-09-08/1/main
new file mode 100755
index 0000000000000000000000000000000000000000..febde160f5fa3c9376f12633927428b6c64c7103
GIT binary patch
literal 43968
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
KxC(Ju<^KXl_mist

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-09-08/1/main.cpp b/exams/AxelRubini/2025-09-08/1/main.cpp
new file mode 100644
index 0000000..1239923
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/main.cpp
@@ -0,0 +1,93 @@
+#include "include/Geometry.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct UAV {
+    Point3D pos;
+};
+
+double runOneSimulation(
+    double T,
+    double H,
+    int N,
+    double L,
+    double V,
+    double A,
+    double D,
+    RandomGenerator &rng
+) {
+    std::vector<UAV> uavs(N);
+    for (int i = 0; i < N; ++i) {
+        uavs[i].pos = {
+            rng.uniform(-L, L), rng.uniform(-L, L), rng.uniform(-L, L)
+        };
+    }
+
+    long long totalCollisions = 0;
+    int steps = 0;
+
+    // Time loop: t*T <= H
+    for (int t = 0; (double)t * T <= H + 1e-9; ++t) {
+        // 1. Check collisions at CURRENT position (t)
+        for (int i = 0; i < N; ++i) {
+            for (int j = i + 1; j < N; ++j) {
+                if (uavs[i].pos.distanceTo(uavs[j].pos) <= D) {
+                    totalCollisions++;
+                }
+            }
+        }
+
+        // 2. Move for NEXT step (t+1)
+        for (int i = 0; i < N; ++i) {
+            // axis k=1,2,3
+            double x[3] = {uavs[i].pos.x, uavs[i].pos.y, uavs[i].pos.z};
+            double new_x[3];
+            for (int k = 0; k < 3; ++k) {
+                double prob = std::exp(-A * (x[k] + L) / (2.0 * L));
+                double vk =
+                    (rng.bernoulli(std::clamp(prob, 0.0, 1.0))) ? V : -V;
+                new_x[k] = x[k] + vk * T;
+            }
+            uavs[i].pos = {new_x[0], new_x[1], new_x[2]};
+        }
+    }
+
+    return (double)totalCollisions / H;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double T = parser.getDouble("T");
+    double H = parser.getDouble("H");
+    int M = parser.getInt("M");
+    int N = parser.getInt("N");
+    double L = parser.getDouble("L");
+    double V = parser.getDouble("V");
+    double A = parser.getDouble("A");
+    double D = parser.getDouble("D");
+
+    double totalRate = 0;
+    for (int i = 0; i < M; ++i) {
+        totalRate += SELib::runOneSimulation(T, H, N, L, V, A, D, rng);
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-09-08-Axel-Rubini-2158099" << std::endl;
+    outFile << "C " << totalRate / M << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-09-08/1/parameters.txt b/exams/AxelRubini/2025-09-08/1/parameters.txt
new file mode 100644
index 0000000..2770776
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/parameters.txt
@@ -0,0 +1,8 @@
+T 1
+H 1000
+M 100
+N 10
+L 1
+V 1
+A 10
+D 1
diff --git a/exams/AxelRubini/2025-09-08/1/results.txt b/exams/AxelRubini/2025-09-08/1/results.txt
new file mode 100644
index 0000000..44d0e69
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/1/results.txt
@@ -0,0 +1,2 @@
+2025-09-08-Axel-Rubini-2158099
+C 11.355
diff --git a/exams/AxelRubini/2025-09-08/2/Makefile b/exams/AxelRubini/2025-09-08/2/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-09-08/2/include/DES.hpp b/exams/AxelRubini/2025-09-08/2/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/2/include/Decision.hpp b/exams/AxelRubini/2025-09-08/2/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/2/include/Dynamics.hpp b/exams/AxelRubini/2025-09-08/2/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/2/include/Geometry.hpp b/exams/AxelRubini/2025-09-08/2/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/2/include/IO.hpp b/exams/AxelRubini/2025-09-08/2/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/2/include/Inventory.hpp b/exams/AxelRubini/2025-09-08/2/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/2/include/Queue.hpp b/exams/AxelRubini/2025-09-08/2/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/2/include/Random.hpp b/exams/AxelRubini/2025-09-08/2/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/2/include/Stat.hpp b/exams/AxelRubini/2025-09-08/2/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/2/main b/exams/AxelRubini/2025-09-08/2/main
new file mode 100755
index 0000000000000000000000000000000000000000..77df3d89cffcf7aac16b4a88e002f872a4b242b7
GIT binary patch
literal 43840
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
E0{oXK-v9sr

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-09-08/2/main.cpp b/exams/AxelRubini/2025-09-08/2/main.cpp
new file mode 100644
index 0000000..9106871
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/main.cpp
@@ -0,0 +1,120 @@
+#include "include/Geometry.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct UAV {
+    Point3D pos;
+};
+
+double calculateD(const Point3D &z, const std::vector<UAV> &uavs, double L) {
+    double total = 0;
+    for (const auto &u : uavs) {
+        double d2 = std::pow((z.x - u.pos.x) / (2.0 * L), 2) +
+                    std::pow((z.y - u.pos.y) / (2.0 * L), 2) +
+                    std::pow((z.z - u.pos.z) / (2.0 * L), 2);
+        total += d2;
+    }
+    return total;
+}
+
+double runOneSimulationAvoidance(
+    double T,
+    double H,
+    int N,
+    double L,
+    double V,
+    double D,
+    RandomGenerator &rng
+) {
+    std::vector<UAV> uavs(N);
+    for (int i = 0; i < N; ++i)
+        uavs[i].pos = {
+            rng.uniform(-L, L), rng.uniform(-L, L), rng.uniform(-L, L)
+        };
+
+    long long totalCollisions = 0;
+    for (int t = 0; (double)t * T <= H + 1e-9; ++t) {
+        for (int i = 0; i < N; ++i) {
+            for (int j = i + 1; j < N; ++j) {
+                if (uavs[i].pos.distanceTo(uavs[j].pos) <= D)
+                    totalCollisions++;
+            }
+        }
+
+        std::vector<Point3D> nextPos(N);
+        for (int i = 0; i < N; ++i) {
+            double minVal = 1e18;
+            std::vector<Point3D> bestMoves;
+            for (int bit = 0; bit < 8; ++bit) {
+                double v1 = (bit & 1) ? V : -V;
+                double v2 = (bit & 2) ? V : -V;
+                double v3 = (bit & 4) ? V : -V;
+                Point3D potential = {
+                    uavs[i].pos.x + v1 * T,
+                    uavs[i].pos.y + v2 * T,
+                    uavs[i].pos.z + v3 * T
+                };
+
+                // Text says: d(xi(V1,V2,V3, t+1), t)
+                // This sum includes j=i? The formula says sum j=1 to N.
+                double val = 0;
+                for (int j = 0; j < N; ++j) {
+                    if (i == j)
+                        continue; // Usually avoidance doesn't include
+                                  // self-distance which is 0 anyway?
+                    // Actually, if we include j=i, the term is (v*T/2L)^2 which
+                    // is constant.
+                    val +=
+                        std::pow((potential.x - uavs[j].pos.x) / (2.0 * L), 2) +
+                        std::pow((potential.y - uavs[j].pos.y) / (2.0 * L), 2) +
+                        std::pow((potential.z - uavs[j].pos.z) / (2.0 * L), 2);
+                }
+
+                if (val < minVal - 1e-12) {
+                    minVal = val;
+                    bestMoves.clear();
+                    bestMoves.push_back(potential);
+                } else if (std::abs(val - minVal) < 1e-12) {
+                    bestMoves.push_back(potential);
+                }
+            }
+            nextPos[i] =
+                bestMoves[rng.uniformInt(0, (int)bestMoves.size() - 1)];
+        }
+        for (int i = 0; i < N; ++i)
+            uavs[i].pos = nextPos[i];
+    }
+    return (double)totalCollisions / H;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double T = parser.getDouble("T"), H = parser.getDouble("H"),
+           L = parser.getDouble("L"), V = parser.getDouble("V"),
+           D = parser.getDouble("D");
+    int M = parser.getInt("M"), N = parser.getInt("N");
+
+    double totalRate = 0;
+    for (int i = 0; i < M; ++i)
+        totalRate += SELib::runOneSimulationAvoidance(T, H, N, L, V, D, rng);
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-09-08-Axel-Rubini-2158099" << std::endl;
+    outFile << "C " << totalRate / M << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-09-08/2/parameters.txt b/exams/AxelRubini/2025-09-08/2/parameters.txt
new file mode 100644
index 0000000..2770776
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/parameters.txt
@@ -0,0 +1,8 @@
+T 1
+H 1000
+M 100
+N 10
+L 1
+V 1
+A 10
+D 1
diff --git a/exams/AxelRubini/2025-09-08/2/results.txt b/exams/AxelRubini/2025-09-08/2/results.txt
new file mode 100644
index 0000000..8440253
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/2/results.txt
@@ -0,0 +1,2 @@
+2025-09-08-Axel-Rubini-2158099
+C 11.8618
diff --git a/exams/AxelRubini/2025-09-08/3/Makefile b/exams/AxelRubini/2025-09-08/3/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-09-08/3/include/DES.hpp b/exams/AxelRubini/2025-09-08/3/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/3/include/Decision.hpp b/exams/AxelRubini/2025-09-08/3/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/3/include/Dynamics.hpp b/exams/AxelRubini/2025-09-08/3/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/3/include/Geometry.hpp b/exams/AxelRubini/2025-09-08/3/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/3/include/IO.hpp b/exams/AxelRubini/2025-09-08/3/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/3/include/Inventory.hpp b/exams/AxelRubini/2025-09-08/3/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/3/include/Queue.hpp b/exams/AxelRubini/2025-09-08/3/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/3/include/Random.hpp b/exams/AxelRubini/2025-09-08/3/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/3/include/Stat.hpp b/exams/AxelRubini/2025-09-08/3/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/3/main b/exams/AxelRubini/2025-09-08/3/main
new file mode 100755
index 0000000000000000000000000000000000000000..de4ada5bc53b67abf432c6f62f40ce770215f560
GIT binary patch
literal 47896
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
UqW4{gQTo>Jc`i4mLQGcr-!el4K>z>%

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-09-08/3/main.cpp b/exams/AxelRubini/2025-09-08/3/main.cpp
new file mode 100644
index 0000000..f8a1786
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/main.cpp
@@ -0,0 +1,105 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Server {
+    std::vector<int> inventory;
+};
+
+struct Event {
+    double time;
+    int type; // 1: Supplier (Higher Priority), 0: Customer
+    int productId;
+    Event(double t, int tp, int pId) : time(t), type(tp), productId(pId) {}
+    // Priority: smaller time first. If same time, larger type first (Supplier=1
+    // > Customer=0)
+    bool operator>(const Event &other) const {
+        if (std::abs(time - other.time) > 1e-9)
+            return time > other.time;
+        return type < other.type;
+    }
+};
+
+double runOneSim(
+    double T,
+    double H,
+    int C,
+    double A,
+    double B,
+    int F,
+    double V,
+    double Q,
+    int P,
+    int S,
+    int K,
+    RandomGenerator &rng
+) {
+    std::priority_queue<Event, std::vector<Event>, std::greater<Event>> eq;
+    std::vector<Server> servers(S);
+    for (int i = 0; i < S; ++i) {
+        servers[i].inventory.assign(P + 1, 0);
+        for (int j = 1; j <= P; ++j)
+            servers[i].inventory[j] = K;
+    }
+
+    for (int i = 0; i < C; ++i)
+        eq.push(Event(rng.uniform(0, B), 0, rng.uniformInt(1, P)));
+    for (int i = 0; i < F; ++i)
+        eq.push(Event(rng.uniform(0, Q), 1, rng.uniformInt(1, P)));
+
+    long long failedSales = 0;
+    while (!eq.empty()) {
+        Event e = eq.top();
+        eq.pop();
+        if (e.time > H)
+            break;
+
+        if (e.type == 0) { // Customer
+            int sIdx = rng.uniformInt(0, S - 1);
+            if (servers[sIdx].inventory[e.productId] > 0)
+                servers[sIdx].inventory[e.productId]--;
+            else
+                failedSales++;
+            eq.push(Event(e.time + rng.uniform(0, B), 0, rng.uniformInt(1, P)));
+        } else { // Supplier
+            int sIdx = rng.uniformInt(0, S - 1);
+            servers[sIdx].inventory[e.productId] += 10;
+            eq.push(Event(e.time + rng.uniform(0, Q), 1, rng.uniformInt(1, P)));
+        }
+    }
+    return (double)failedSales / (H / T);
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double T = parser.getDouble("T"), H = parser.getDouble("H");
+    int M = parser.getInt("M"), C = parser.getInt("C");
+    double A = parser.getDouble("A"), B = parser.getDouble("B");
+    int F = parser.getInt("F");
+    double V = parser.getDouble("V"), Q = parser.getDouble("Q");
+    int P = parser.getInt("P"), S = parser.getInt("S"),
+        K = parser.getInt("K", 1);
+
+    double totalRate = 0;
+    for (int i = 0; i < M; ++i)
+        totalRate += SELib::runOneSim(T, H, C, A, B, F, V, Q, P, S, K, rng);
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-09-08-Axel-Rubini-2158099" << std::endl;
+    outFile << "R " << totalRate / M << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-09-08/3/parameters.txt b/exams/AxelRubini/2025-09-08/3/parameters.txt
new file mode 100644
index 0000000..adc02a6
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/parameters.txt
@@ -0,0 +1,12 @@
+T 0.1
+H 100
+M 100
+C 100
+A 1.0
+B 1.0
+F 1
+V 1
+Q 1
+P 1
+S 1
+K 1
diff --git a/exams/AxelRubini/2025-09-08/3/results.txt b/exams/AxelRubini/2025-09-08/3/results.txt
new file mode 100644
index 0000000..fabcd57
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/3/results.txt
@@ -0,0 +1,2 @@
+2025-09-08-Axel-Rubini-2158099
+R 17.9675
diff --git a/exams/AxelRubini/2025-09-08/4/Makefile b/exams/AxelRubini/2025-09-08/4/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-09-08/4/include/DES.hpp b/exams/AxelRubini/2025-09-08/4/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/4/include/Decision.hpp b/exams/AxelRubini/2025-09-08/4/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/4/include/Dynamics.hpp b/exams/AxelRubini/2025-09-08/4/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/4/include/Geometry.hpp b/exams/AxelRubini/2025-09-08/4/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/4/include/IO.hpp b/exams/AxelRubini/2025-09-08/4/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/4/include/Inventory.hpp b/exams/AxelRubini/2025-09-08/4/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/4/include/Queue.hpp b/exams/AxelRubini/2025-09-08/4/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/4/include/Random.hpp b/exams/AxelRubini/2025-09-08/4/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/4/include/Stat.hpp b/exams/AxelRubini/2025-09-08/4/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/4/main b/exams/AxelRubini/2025-09-08/4/main
new file mode 100755
index 0000000000000000000000000000000000000000..6042d8b2cf01e3419808690d3922c73c3ca12f7c
GIT binary patch
literal 47952
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
IaY^a_0Zm*;*#H0l

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-09-08/4/main.cpp b/exams/AxelRubini/2025-09-08/4/main.cpp
new file mode 100644
index 0000000..931335d
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/main.cpp
@@ -0,0 +1,119 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Server {
+    std::vector<int> inventory;
+};
+
+struct Event {
+    double time;
+    int type;
+    int productId;
+    Event(double t, int tp, int pId) : time(t), type(tp), productId(pId) {}
+    bool operator>(const Event &other) const { return time > other.time; }
+};
+
+double runMsims(
+    int F,
+    int M,
+    double T,
+    double H,
+    int C,
+    double A,
+    double B,
+    double V,
+    double Q,
+    int P,
+    int S,
+    int K,
+    RandomGenerator &rng
+) {
+    double totalR = 0;
+    for (int m = 0; m < M; ++m) {
+        std::priority_queue<Event, std::vector<Event>, std::greater<Event>> eq;
+        std::vector<Server> servers(S);
+        for (int i = 0; i < S; ++i) {
+            servers[i].inventory.assign(P + 1, 0);
+            for (int j = 1; j <= P; ++j)
+                servers[i].inventory[j] = K;
+        }
+        for (int i = 0; i < C; ++i)
+            eq.push(Event(rng.uniform(A, B), 0, rng.uniformInt(1, P)));
+        for (int i = 0; i < F; ++i)
+            eq.push(Event(rng.uniform(V, Q), 1, rng.uniformInt(1, P)));
+
+        long long failed = 0;
+        while (!eq.empty()) {
+            Event e = eq.top();
+            eq.pop();
+            if (e.time > H)
+                break;
+            if (e.type == 0) {
+                int sIdx = rng.uniformInt(0, S - 1);
+                if (servers[sIdx].inventory[e.productId] > 0)
+                    servers[sIdx].inventory[e.productId]--;
+                else
+                    failed++;
+                eq.push(
+                    Event(e.time + rng.uniform(A, B), 0, rng.uniformInt(1, P))
+                );
+            } else {
+                int sIdx = rng.uniformInt(0, S - 1);
+                servers[sIdx].inventory[e.productId] += 10;
+                eq.push(
+                    Event(e.time + rng.uniform(V, Q), 1, rng.uniformInt(1, P))
+                );
+            }
+        }
+        totalR += (double)failed / H;
+    }
+    return totalR / M;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double T = parser.getDouble("T"), H = parser.getDouble("H");
+    int M = parser.getInt("M"), C = parser.getInt("C");
+    double A = parser.getDouble("A"), B = parser.getDouble("B");
+    int G_budget = parser.getInt("G");
+    double V = parser.getDouble("V"), Q = parser.getDouble("Q");
+    int P = parser.getInt("P"), S = parser.getInt("S"),
+        K = parser.getInt("K", 1);
+
+    int bestF = 1;
+    double minJ = 1e18;
+    double bestR = 0;
+
+    for (int i = 0; i < G_budget; ++i) {
+        int F = rng.uniformInt(1, 100);
+        double R = SELib::runMsims(F, M, T, H, C, A, B, V, Q, P, S, K, rng);
+        double J = 10.0 * F + 2.0 * R;
+        if (J < minJ) {
+            minJ = J;
+            bestF = F;
+            bestR = R;
+        }
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-09-08-Axel-Rubini-2158099" << std::endl;
+    outFile << "R " << bestR << std::endl;
+    outFile << "F " << bestF << std::endl;
+    outFile << "J " << minJ << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-09-08/4/parameters.txt b/exams/AxelRubini/2025-09-08/4/parameters.txt
new file mode 100644
index 0000000..838fc96
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/parameters.txt
@@ -0,0 +1,12 @@
+T 0.1
+H 100
+M 100
+C 200
+A 1
+B 1
+G 20
+V 0.1
+Q 0.1
+P 1
+S 1
+K 1
diff --git a/exams/AxelRubini/2025-09-08/4/results.txt b/exams/AxelRubini/2025-09-08/4/results.txt
new file mode 100644
index 0000000..32c4608
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/4/results.txt
@@ -0,0 +1,4 @@
+2025-09-08-Axel-Rubini-2158099
+R 0
+F 13
+J 130
diff --git a/exams/AxelRubini/2025-09-08/5/Makefile b/exams/AxelRubini/2025-09-08/5/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-09-08/5/include/DES.hpp b/exams/AxelRubini/2025-09-08/5/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/5/include/Decision.hpp b/exams/AxelRubini/2025-09-08/5/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/5/include/Dynamics.hpp b/exams/AxelRubini/2025-09-08/5/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/5/include/Geometry.hpp b/exams/AxelRubini/2025-09-08/5/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/5/include/IO.hpp b/exams/AxelRubini/2025-09-08/5/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/5/include/Inventory.hpp b/exams/AxelRubini/2025-09-08/5/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/5/include/Queue.hpp b/exams/AxelRubini/2025-09-08/5/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/5/include/Random.hpp b/exams/AxelRubini/2025-09-08/5/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/5/include/Stat.hpp b/exams/AxelRubini/2025-09-08/5/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-09-08/5/main b/exams/AxelRubini/2025-09-08/5/main
new file mode 100755
index 0000000000000000000000000000000000000000..ee912f6c171de2075a85743abefcb90000d91a8b
GIT binary patch
literal 47896
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
Y_4Ft_=xx_w6u<LFp2{9lU`SH>U;pd14FCWD

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-09-08/5/main.cpp b/exams/AxelRubini/2025-09-08/5/main.cpp
new file mode 100644
index 0000000..48fc3d3
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/main.cpp
@@ -0,0 +1,120 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Server {
+    std::vector<int> inventory;
+};
+
+struct Event {
+    double time;
+    int type;
+    int productId;
+    Event(double t, int tp, int pId) : time(t), type(tp), productId(pId) {}
+    bool operator>(const Event &other) const { return time > other.time; }
+};
+
+struct Result {
+    double R, V, Q, J;
+};
+
+Result runMsims(
+    double V,
+    int M,
+    double T,
+    double H,
+    int C,
+    double A,
+    double B,
+    int F,
+    int P,
+    int S,
+    int K,
+    RandomGenerator &rng
+) {
+    double Q = V + 5.0;
+    double totalR = 0;
+    for (int m = 0; m < M; ++m) {
+        std::priority_queue<Event, std::vector<Event>, std::greater<Event>> eq;
+        std::vector<Server> servers(S);
+        for (int i = 0; i < S; ++i) {
+            servers[i].inventory.assign(P + 1, 0);
+            for (int j = 1; j <= P; ++j)
+                servers[i].inventory[j] = K;
+        }
+        for (int i = 0; i < C; ++i)
+            eq.push(Event(rng.uniform(A, B), 0, rng.uniformInt(1, P)));
+        for (int i = 0; i < F; ++i)
+            eq.push(Event(rng.uniform(V, Q), 1, rng.uniformInt(1, P)));
+
+        long long failed = 0;
+        while (!eq.empty()) {
+            Event e = eq.top();
+            eq.pop();
+            if (e.time > H)
+                break;
+            if (e.type == 0) {
+                int sIdx = rng.uniformInt(0, S - 1);
+                if (servers[sIdx].inventory[e.productId] > 0)
+                    servers[sIdx].inventory[e.productId]--;
+                else
+                    failed++;
+                eq.push(
+                    Event(e.time + rng.uniform(A, B), 0, rng.uniformInt(1, P))
+                );
+            } else {
+                int sIdx = rng.uniformInt(0, S - 1);
+                servers[sIdx].inventory[e.productId]++;
+                eq.push(
+                    Event(e.time + rng.uniform(V, Q), 1, rng.uniformInt(1, P))
+                );
+            }
+        }
+        totalR += (double)failed / H;
+    }
+    double R = totalR / M;
+    return {R, V, Q, 10.0 * V + 2.0 * R};
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double T = parser.getDouble("T"), H = parser.getDouble("H");
+    int M = parser.getInt("M"), C = parser.getInt("C");
+    double A = parser.getDouble("A"), B = parser.getDouble("B");
+    int F = parser.getInt("F"), G_budget = parser.getInt("G");
+    int P = parser.getInt("P"), S = parser.getInt("S"),
+        K = parser.getInt("K", 1);
+
+    double bestV = 0;
+    SELib::Result bestRes = {0, 0, 0, 1e18};
+
+    for (int i = 0; i < G_budget; ++i) {
+        double V = rng.uniform(0.1, 10.0);
+        auto res = SELib::runMsims(V, M, T, H, C, A, B, F, P, S, K, rng);
+        if (res.J < bestRes.J) {
+            bestRes = res;
+        }
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-09-08-Axel-Rubini-2158099" << std::endl;
+    outFile << "R " << bestRes.R << std::endl;
+    outFile << "V " << bestRes.V << std::endl;
+    outFile << "Q " << bestRes.Q << std::endl;
+    outFile << "J " << bestRes.J << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-09-08/5/parameters.txt b/exams/AxelRubini/2025-09-08/5/parameters.txt
new file mode 100644
index 0000000..850217c
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/parameters.txt
@@ -0,0 +1,11 @@
+T 10
+H 1000
+M 100
+C 100
+A 10
+B 10
+F 10
+G 20
+P 1
+S 1
+K 1
diff --git a/exams/AxelRubini/2025-09-08/5/results.txt b/exams/AxelRubini/2025-09-08/5/results.txt
new file mode 100644
index 0000000..e0c24fc
--- /dev/null
+++ b/exams/AxelRubini/2025-09-08/5/results.txt
@@ -0,0 +1,5 @@
+2025-09-08-Axel-Rubini-2158099
+R 6.33914
+V 0.234785
+Q 5.23478
+J 15.0261
diff --git a/exams/AxelRubini/2025-11-03/1/Makefile b/exams/AxelRubini/2025-11-03/1/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-11-03/1/include/DES.hpp b/exams/AxelRubini/2025-11-03/1/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/1/include/Decision.hpp b/exams/AxelRubini/2025-11-03/1/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/1/include/Dynamics.hpp b/exams/AxelRubini/2025-11-03/1/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/1/include/Geometry.hpp b/exams/AxelRubini/2025-11-03/1/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/1/include/IO.hpp b/exams/AxelRubini/2025-11-03/1/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/1/include/Inventory.hpp b/exams/AxelRubini/2025-11-03/1/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/1/include/Queue.hpp b/exams/AxelRubini/2025-11-03/1/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/1/include/Random.hpp b/exams/AxelRubini/2025-11-03/1/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/1/include/Stat.hpp b/exams/AxelRubini/2025-11-03/1/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/1/main b/exams/AxelRubini/2025-11-03/1/main
new file mode 100755
index 0000000000000000000000000000000000000000..86940d243a584e5c5370c71f5599ced3bfd055ed
GIT binary patch
literal 43848
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-11-03/1/main.cpp b/exams/AxelRubini/2025-11-03/1/main.cpp
new file mode 100644
index 0000000..00b2b84
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/main.cpp
@@ -0,0 +1,39 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    int N = parser.getInt("N");
+    int M = parser.getInt("M");
+
+    SELib::MDP mdp(N, rng);
+    const auto &data = parser.getStructuredData();
+    for (const auto &line : data) {
+        if (line.size() == 5 && line[0] == "A") {
+            int i = std::stoi(line[1]);
+            int j = std::stoi(line[2]);
+            double p = std::stod(line[3]);
+            double c = std::stod(line[4]);
+            mdp.addTransition(i, j, p, c);
+        }
+    }
+
+    double totalCost = 0;
+    for (int i = 0; i < M; ++i) {
+        totalCost += mdp.simulate(0, N - 1);
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-11-03-Axel-Rubini-2158099" << std::endl;
+    outFile << "C " << totalCost / M << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-11-03/1/parameters.txt b/exams/AxelRubini/2025-11-03/1/parameters.txt
new file mode 100644
index 0000000..b7435a0
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/parameters.txt
@@ -0,0 +1,18 @@
+N 5
+M 100
+A 0 0 0.4 50
+A 0 1 0.6 100
+A 1 0 0.1 150
+A 1 1 0.2 100
+A 1 2 0.7 50
+A 2 0 0.1 200
+A 2 1 0.1 150
+A 2 2 0.2 100
+A 2 3 0.6 50
+A 3 0 0.1 200
+A 3 1 0.1 150
+A 3 2 0.1 100
+A 3 3 0.1 50
+A 3 4 0.6 50
+A 4 4 1 0
+
diff --git a/exams/AxelRubini/2025-11-03/1/results.txt b/exams/AxelRubini/2025-11-03/1/results.txt
new file mode 100644
index 0000000..c64cd26
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/1/results.txt
@@ -0,0 +1,2 @@
+2025-11-03-Axel-Rubini-2158099
+C 738.5
diff --git a/exams/AxelRubini/2025-11-03/2/Makefile b/exams/AxelRubini/2025-11-03/2/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-11-03/2/include/DES.hpp b/exams/AxelRubini/2025-11-03/2/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/2/include/Decision.hpp b/exams/AxelRubini/2025-11-03/2/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/2/include/Dynamics.hpp b/exams/AxelRubini/2025-11-03/2/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/2/include/Geometry.hpp b/exams/AxelRubini/2025-11-03/2/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/2/include/IO.hpp b/exams/AxelRubini/2025-11-03/2/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/2/include/Inventory.hpp b/exams/AxelRubini/2025-11-03/2/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/2/include/Queue.hpp b/exams/AxelRubini/2025-11-03/2/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/2/include/Random.hpp b/exams/AxelRubini/2025-11-03/2/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/2/include/Stat.hpp b/exams/AxelRubini/2025-11-03/2/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/2/main b/exams/AxelRubini/2025-11-03/2/main
new file mode 100755
index 0000000000000000000000000000000000000000..01bbcf40d199cc3005879e4ec7cbbd48cb155a56
GIT binary patch
literal 44016
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
P<1Zw}<b(<dS>^u$Goc!G

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-11-03/2/main.cpp b/exams/AxelRubini/2025-11-03/2/main.cpp
new file mode 100644
index 0000000..f87d892
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/main.cpp
@@ -0,0 +1,42 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    int N = parser.getInt("N");
+    int M = parser.getInt("M");
+    double VMax = parser.getDouble("C");
+
+    SELib::MDP mdp(N, rng);
+    const auto &data = parser.getStructuredData();
+    for (const auto &line : data) {
+        if (line.size() == 5 && line[0] == "A") {
+            mdp.addTransition(
+                std::stoi(line[1]),
+                std::stoi(line[2]),
+                std::stod(line[3]),
+                std::stod(line[4])
+            );
+        }
+    }
+
+    SELib::MonteCarloSimulator simulator(M);
+    double prob = simulator.estimateProbability([&](int) {
+        return mdp.simulate(0, N - 1) <= VMax;
+    });
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-11-03-Axel-Rubini-2158099" << std::endl;
+    outFile << "P " << std::fixed << std::setprecision(6) << prob << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-11-03/2/parameters.txt b/exams/AxelRubini/2025-11-03/2/parameters.txt
new file mode 100644
index 0000000..0002bfe
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/parameters.txt
@@ -0,0 +1,18 @@
+N 5
+M 1000
+A 0 0 0.4 50
+A 0 1 0.6 100
+A 1 0 0.1 150
+A 1 1 0.2 100
+A 1 2 0.7 50
+A 2 0 0.1 200
+A 2 1 0.1 150
+A 2 2 0.2 100
+A 2 3 0.6 50
+A 3 0 0.1 200
+A 3 1 0.1 150
+A 3 2 0.1 100
+A 3 3 0.1 50
+A 3 4 0.6 50
+A 4 4 1 0
+C 700
diff --git a/exams/AxelRubini/2025-11-03/2/results.txt b/exams/AxelRubini/2025-11-03/2/results.txt
new file mode 100644
index 0000000..48ee9b4
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/2/results.txt
@@ -0,0 +1,2 @@
+2025-11-03-Axel-Rubini-2158099
+P 0.635000
diff --git a/exams/AxelRubini/2025-11-03/3/Makefile b/exams/AxelRubini/2025-11-03/3/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2025-11-03/3/include/DES.hpp b/exams/AxelRubini/2025-11-03/3/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/3/include/Decision.hpp b/exams/AxelRubini/2025-11-03/3/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/3/include/Dynamics.hpp b/exams/AxelRubini/2025-11-03/3/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/3/include/Geometry.hpp b/exams/AxelRubini/2025-11-03/3/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/3/include/IO.hpp b/exams/AxelRubini/2025-11-03/3/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/3/include/Inventory.hpp b/exams/AxelRubini/2025-11-03/3/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/3/include/Queue.hpp b/exams/AxelRubini/2025-11-03/3/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/3/include/Random.hpp b/exams/AxelRubini/2025-11-03/3/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/3/include/Stat.hpp b/exams/AxelRubini/2025-11-03/3/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/3/main b/exams/AxelRubini/2025-11-03/3/main
new file mode 100755
index 0000000000000000000000000000000000000000..fa300b5368561d85eb890abdf5d2a7129c7e677e
GIT binary patch
literal 52528
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
F?iOu<I|={*

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-11-03/3/main.cpp b/exams/AxelRubini/2025-11-03/3/main.cpp
new file mode 100644
index 0000000..dfe39c0
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/main.cpp
@@ -0,0 +1,72 @@
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    int N = parser.getInt("N");
+    int M = parser.getInt("M");
+    int B = parser.getInt("B");
+    double K_val = parser.getDouble("K");
+
+    struct Trans {
+        int i, j;
+        double p, c;
+    };
+    std::vector<Trans> fixed;
+    double c00 = 0, c01 = 0;
+
+    const auto &data = parser.getStructuredData();
+    for (const auto &line : data) {
+        if (line.size() == 5 && line[0] == "A") {
+            int i = std::stoi(line[1]), j = std::stoi(line[2]);
+            double p = std::stod(line[3]), c = std::stod(line[4]);
+            if (i == 0 && j == 0)
+                c00 = c;
+            else if (i == 0 && j == 1)
+                c01 = c;
+            else
+                fixed.push_back({i, j, p, c});
+        }
+    }
+
+    auto objective = [&](double p) {
+        SELib::MDP mdp(N, rng);
+        for (auto &t : fixed)
+            mdp.addTransition(t.i, t.j, t.p, t.c);
+        mdp.addTransition(0, 0, p, c00);
+        mdp.addTransition(0, 1, 1.0 - p, c01);
+
+        SELib::MonteCarloSimulator sim(M);
+        double EC = sim.estimate([&](int) { return mdp.simulate(0, N - 1); });
+        return K_val * (1.0 - p) + EC;
+    };
+
+    auto [bestP, minJ] =
+        SELib::Optimizer::randomSearch(objective, 0.0, 0.9, B, rng, false);
+
+    // Final eval
+    SELib::MDP mdp(N, rng);
+    for (auto &t : fixed)
+        mdp.addTransition(t.i, t.j, t.p, t.c);
+    mdp.addTransition(0, 0, bestP, c00);
+    mdp.addTransition(0, 1, 1.0 - bestP, c01);
+    SELib::MonteCarloSimulator sim(M);
+    double finalC = sim.estimate([&](int) { return mdp.simulate(0, N - 1); });
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-11-03-Axel-Rubini-2158099" << std::endl;
+    outFile << "p " << bestP << std::endl;
+    outFile << "C " << finalC << std::endl;
+    outFile << "J " << minJ << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-11-03/3/parameters.txt b/exams/AxelRubini/2025-11-03/3/parameters.txt
new file mode 100644
index 0000000..d733326
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/parameters.txt
@@ -0,0 +1,19 @@
+N 5
+M 100
+A 0 0 0 50
+A 0 1 0 100
+A 1 0 0.1 150
+A 1 1 0.2 100
+A 1 2 0.7 50
+A 2 0 0.1 200
+A 2 1 0.1 150
+A 2 2 0.2 100
+A 2 3 0.6 50
+A 3 0 0.1 200
+A 3 1 0.1 150
+A 3 2 0.1 100
+A 3 3 0.1 50
+A 3 4 0.6 50
+A 4 4 1 0
+B 100
+K 400
diff --git a/exams/AxelRubini/2025-11-03/3/results.txt b/exams/AxelRubini/2025-11-03/3/results.txt
new file mode 100644
index 0000000..f5b4e42
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/3/results.txt
@@ -0,0 +1,4 @@
+2025-11-03-Axel-Rubini-2158099
+p 0.705064
+C 867
+J 868.475
diff --git a/exams/AxelRubini/2025-11-03/4/include/DES.hpp b/exams/AxelRubini/2025-11-03/4/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/4/include/Decision.hpp b/exams/AxelRubini/2025-11-03/4/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/4/include/Dynamics.hpp b/exams/AxelRubini/2025-11-03/4/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/4/include/Geometry.hpp b/exams/AxelRubini/2025-11-03/4/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/4/include/IO.hpp b/exams/AxelRubini/2025-11-03/4/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/4/include/Inventory.hpp b/exams/AxelRubini/2025-11-03/4/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/4/include/Queue.hpp b/exams/AxelRubini/2025-11-03/4/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/4/include/Random.hpp b/exams/AxelRubini/2025-11-03/4/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/4/include/Stat.hpp b/exams/AxelRubini/2025-11-03/4/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/4/main b/exams/AxelRubini/2025-11-03/4/main
new file mode 100755
index 0000000000000000000000000000000000000000..dcf301e982a1630a983bf985277b84e05b4696e3
GIT binary patch
literal 57600
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
NfhRAfLQGcqe*iQ025|rY

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-11-03/4/main.cpp b/exams/AxelRubini/2025-11-03/4/main.cpp
new file mode 100644
index 0000000..ec91b88
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/main.cpp
@@ -0,0 +1,117 @@
+#include "include/DES.hpp"
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Params {
+    double T, H;
+    int M;
+    double A, B, V, W;
+    int P, K;
+    double p;
+    int Q;
+};
+
+class Customer : public DiscreteEventProcess {
+  public:
+    Customer(Params &p, RandomGenerator &r, std::queue<int> &q)
+        : p_(p), rng_(r), q_(q) {}
+    void initialize(double start) override {
+        next_ = start + rng_.uniform(p_.A, p_.B);
+    }
+    double nextEventTime() const override { return next_; }
+    void handleEvent(double t) override {
+        q_.push(rng_.uniformInt(1, p_.P));
+        next_ = t + rng_.uniform(p_.A, p_.B);
+    }
+
+  private:
+    Params &p_;
+    RandomGenerator &rng_;
+    std::queue<int> &q_;
+    double next_;
+};
+
+class Server : public DiscreteEventProcess {
+  public:
+    Server(Params &p, RandomGenerator &r, std::queue<int> &q, long long &ms)
+        : p_(p), rng_(r), q_(q), ms_(ms) {
+        inv_.assign(p_.P + 1, 0);
+    }
+    void initialize(double start) override {
+        for (int i = 1; i <= p_.P; ++i)
+            inv_[i] = rng_.uniformInt(0, p_.K);
+        next_ = start + rng_.uniform(p_.V, p_.W);
+    }
+    double nextEventTime() const override { return next_; }
+    void handleEvent(double t) override {
+        if (!q_.empty()) {
+            int j = q_.front();
+            q_.pop();
+            if (inv_[j] > 0)
+                inv_[j]--;
+            else {
+                ms_++;
+                if (rng_.bernoulli(p_.p))
+                    inv_[j] = rng_.uniformInt(0, p_.Q);
+            }
+        }
+        next_ = t + rng_.uniform(p_.V, p_.W);
+    }
+
+  private:
+    Params &p_;
+    RandomGenerator &rng_;
+    std::queue<int> &q_;
+    long long &ms_;
+    std::vector<int> inv_;
+    double next_;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    SELib::Params p;
+    p.T = parser.getDouble("T", 1.0);
+    p.H = parser.getDouble("H");
+    p.M = parser.getInt("M");
+    p.A = parser.getDouble("A");
+    p.B = parser.getDouble("B");
+    p.V = parser.getDouble("V");
+    p.W = parser.getDouble("W");
+    p.P = parser.getInt("P");
+    p.K = parser.getInt("K");
+    p.p = parser.getDouble("p");
+    p.Q = parser.getInt("Q");
+
+    double totalRate = 0;
+    for (int i = 0; i < p.M; ++i) {
+        SELib::DiscreteEventSystem system;
+        std::queue<int> q;
+        long long ms = 0;
+        system.emplaceProcess<SELib::Customer>(p, rng, q);
+        system.emplaceProcess<SELib::Server>(p, rng, q, ms);
+        SELib::DiscreteEventSimulator sim(system);
+        sim.run(p.H);
+        totalRate += (double)ms / p.H;
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-11-03-Axel-Rubini-2158099" << std::endl;
+    outFile << "R " << totalRate / p.M << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-11-03/4/parameters.txt b/exams/AxelRubini/2025-11-03/4/parameters.txt
new file mode 100644
index 0000000..4e4717c
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/parameters.txt
@@ -0,0 +1,10 @@
+T 1.0
+H 10000
+M 10
+A 1.0
+B 2.1
+V 3.0
+W 4.0
+K 3
+P 5
+p 0.9
diff --git a/exams/AxelRubini/2025-11-03/4/results.txt b/exams/AxelRubini/2025-11-03/4/results.txt
new file mode 100644
index 0000000..bcc273b
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/4/results.txt
@@ -0,0 +1,2 @@
+2025-11-03-Axel-Rubini-2158099
+R 0.28484
diff --git a/exams/AxelRubini/2025-11-03/5/include/DES.hpp b/exams/AxelRubini/2025-11-03/5/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/5/include/Decision.hpp b/exams/AxelRubini/2025-11-03/5/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/5/include/Dynamics.hpp b/exams/AxelRubini/2025-11-03/5/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/5/include/Geometry.hpp b/exams/AxelRubini/2025-11-03/5/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/5/include/IO.hpp b/exams/AxelRubini/2025-11-03/5/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/5/include/Inventory.hpp b/exams/AxelRubini/2025-11-03/5/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/5/include/Queue.hpp b/exams/AxelRubini/2025-11-03/5/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/5/include/Random.hpp b/exams/AxelRubini/2025-11-03/5/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/5/include/Stat.hpp b/exams/AxelRubini/2025-11-03/5/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2025-11-03/5/main b/exams/AxelRubini/2025-11-03/5/main
new file mode 100755
index 0000000000000000000000000000000000000000..0aeb6840a64e37402a231ca6db0f0b5f84db37f8
GIT binary patch
literal 57760
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
X5^*$MWZxx>(#3mtE;p(|R95-l13U{`

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2025-11-03/5/main.cpp b/exams/AxelRubini/2025-11-03/5/main.cpp
new file mode 100644
index 0000000..8093c45
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/main.cpp
@@ -0,0 +1,137 @@
+#include "include/DES.hpp"
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct Params {
+    double T, H;
+    int M;
+    double A, B, V, W;
+    int P, K;
+    double p;
+    int Q;
+    double G;
+};
+
+class Customer : public DiscreteEventProcess {
+  public:
+    Customer(Params &p, RandomGenerator &r, std::queue<int> &q)
+        : p_(p), rng_(r), q_(q) {}
+    void initialize(double start) override {
+        next_ = start + rng_.uniform(p_.A, p_.B);
+    }
+    double nextEventTime() const override { return next_; }
+    void handleEvent(double t) override {
+        q_.push(rng_.uniformInt(1, p_.P));
+        next_ = t + rng_.uniform(p_.A, p_.B);
+    }
+
+  private:
+    Params &p_;
+    RandomGenerator &rng_;
+    std::queue<int> &q_;
+    double next_;
+};
+
+class Server : public DiscreteEventProcess {
+  public:
+    Server(Params &p, RandomGenerator &r, std::queue<int> &q, long long &ms)
+        : p_(p), rng_(r), q_(q), ms_(ms) {
+        inv_.assign(p_.P + 1, 0);
+    }
+    void initialize(double start) override {
+        for (int i = 1; i <= p_.P; ++i)
+            inv_[i] = rng_.uniformInt(0, p_.K);
+        next_ = start + rng_.uniform(p_.V, p_.W);
+    }
+    double nextEventTime() const override { return next_; }
+    void handleEvent(double t) override {
+        if (!q_.empty()) {
+            int j = q_.front();
+            q_.pop();
+            if (inv_[j] > 0)
+                inv_[j]--;
+            else {
+                ms_++;
+                if (rng_.bernoulli(p_.p))
+                    inv_[j] = rng_.uniformInt(0, p_.Q);
+            }
+        }
+        next_ = t + rng_.uniform(p_.V, p_.W);
+    }
+
+  private:
+    Params &p_;
+    RandomGenerator &rng_;
+    std::queue<int> &q_;
+    long long &ms_;
+    std::vector<int> inv_;
+    double next_;
+};
+
+double runMsims(double p_val, Params &p, RandomGenerator &rng) {
+    p.p = p_val;
+    double totalRate = 0;
+    for (int i = 0; i < p.M; ++i) {
+        DiscreteEventSystem system;
+        std::queue<int> q;
+        long long ms = 0;
+        system.emplaceProcess<Customer>(p, rng, q);
+        system.emplaceProcess<Server>(p, rng, q, ms);
+        DiscreteEventSimulator sim(system);
+        sim.run(p.H);
+        totalRate += (double)ms / p.H;
+    }
+    return totalRate / p.M;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    SELib::Params p;
+    p.T = parser.getDouble("T", 1.0);
+    p.H = parser.getDouble("H");
+    p.M = parser.getInt("M");
+    p.A = parser.getDouble("A");
+    p.B = parser.getDouble("B");
+    p.V = parser.getDouble("V");
+    p.W = parser.getDouble("W");
+    p.P = parser.getInt("P");
+    p.K = parser.getInt("K");
+    p.Q = parser.getInt("Q");
+    p.G = parser.getDouble("G");
+    int budget = parser.getInt("B", 100);
+
+    double bestP = 0, minJ = 1e18, bestR = 0;
+    for (int i = 0; i < budget; ++i) {
+        double p_val = rng.uniform(0.0, 1.0);
+        double R = SELib::runMsims(p_val, p, rng);
+        double J = p.G * p_val + R;
+        if (J < minJ) {
+            minJ = J;
+            bestP = p_val;
+            bestR = R;
+        }
+    }
+
+    std::ofstream outFile("results.txt");
+    outFile << "2025-11-03-Axel-Rubini-2158099" << std::endl;
+    outFile << "p " << bestP << std::endl;
+    outFile << "R " << bestR << std::endl;
+    outFile << "J " << minJ << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2025-11-03/5/parameters.txt b/exams/AxelRubini/2025-11-03/5/parameters.txt
new file mode 100644
index 0000000..0a31361
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/parameters.txt
@@ -0,0 +1,11 @@
+T 1.0
+H 10000
+M 10
+A 1.0
+B 2.1
+V 3.0
+W 4.0
+K 3
+P 5
+Q 10
+G 0.01
diff --git a/exams/AxelRubini/2025-11-03/5/results.txt b/exams/AxelRubini/2025-11-03/5/results.txt
new file mode 100644
index 0000000..69c48e7
--- /dev/null
+++ b/exams/AxelRubini/2025-11-03/5/results.txt
@@ -0,0 +1,4 @@
+2025-11-03-Axel-Rubini-2158099
+p 0.764934
+R 0.05924
+J 0.0668893
diff --git a/exams/AxelRubini/2026-01-14/1/Makefile b/exams/AxelRubini/2026-01-14/1/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2026-01-14/1/include/DES.hpp b/exams/AxelRubini/2026-01-14/1/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/1/include/Decision.hpp b/exams/AxelRubini/2026-01-14/1/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/1/include/Dynamics.hpp b/exams/AxelRubini/2026-01-14/1/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/1/include/Geometry.hpp b/exams/AxelRubini/2026-01-14/1/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/1/include/IO.hpp b/exams/AxelRubini/2026-01-14/1/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/1/include/Inventory.hpp b/exams/AxelRubini/2026-01-14/1/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/1/include/Queue.hpp b/exams/AxelRubini/2026-01-14/1/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/1/include/Random.hpp b/exams/AxelRubini/2026-01-14/1/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/1/include/Stat.hpp b/exams/AxelRubini/2026-01-14/1/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/1/main b/exams/AxelRubini/2026-01-14/1/main
new file mode 100755
index 0000000000000000000000000000000000000000..35d0a370b916eb6d6d4c583a8fc1369ccbbef4f0
GIT binary patch
literal 43952
zcmeHwdwi6|)&H|e7Q!vhVxgv>b+ro(Rbn<b5*18H7M|4&MiMbzaC6&`lq4II4FrW6
z+yr>KtVV0Cucemu?S;3smG(z1MQRg}o3}>WDlJu`s61=9L{!8Z`}>}mc{WcryOvr%
z@B5FB?#?r3&YU@O=FB-~E@AI*xE3UsOp^X2O7kSjZN7v<3Pi!y{}wMu3Zy(K1>aWb
z0%;8LNesrz3wVN3{#X)6rpW?MV5+xGlt-uM2|PX3Ii!^8#d~_s=Oub7S$Ll6nd#L^
zUwEwSJCgP-;CVeY)?@9p2>hsYr|6KL8taj4q}xTkz{qq9E0m<IBGv090F6Lf)^PkS
z!I7zj5b)@!E>Gf-KBYpQ(P;t7=qX^|k`!I9N7Rc>Z316UsSSE4rO&1g%8gE~3>pz{
zWX#Im@YPbiX#VtkfvBgaI-jMYUgfPEAv%3p)YDU)&udXn7qLM3)I_L@v{<wkZ~VA2
zffQ3JNh1BChuY1+hrkOLT_+`UO1%Wr%T1Dr<;MX=PlCwn<%By09~us-KXdD)FJ50~
zxv+Qn&p*7g_`&zy?|tZ}mo_$3=Vo8pSUbD1p}D<dc1K?B?A+}1Hg9?+t9Lo0D@kLK
z7H&yWIy=qhNIs0k#Em8@n@ezfYCrzt<G(ppTi&{J%w^|%)%uWY-_!lezq@VrO#jw`
zht6x+-rDV&p7Oz|=O$X;I`j1Ox6TC4ed`RW#e8mtkk5%x@<((u7Q6}_js^ekIPkAR
zFtPBTiqmcq1|Syxv^eyC5QqL|@PAQ^eyxntuSep*bD_ww_&GNYpVy<!Soq^G|6{@b
z7)K5d#lfEzhtD~2;CID=x5R-z8V8;cr@tS@;eU3V@mdb$jwOfnape4N9DH{iK2zfG
zQy&L@G>-oKJ`O(@#~GKIarj&iM;~5@ga2P~;6IN8e=80@zBuFcw>aanGERT*i9_ev
zIPLy6PJgeBBWJSPR(ztL(m3PmiUUuD;f<wNYMgP07-F_djvy8t3ahNqOd|iSIQ$gE
zq0<XKFO<G4NgFvao#tW4ncyt~-pPxZGa$G{#34HVPtY%d4+;EKfuDnp5j<JMA3A=Q
zXg5v3I|cqy@JaX?f_|xh--_`ic&C8t_{Ty2B59H&&F6^Z@8~&>58+z{KRTVCp<jew
zTEx(#OrA*XNMpet0Y3!q5%^aMe97%z*5qw=xB04CeQvkpc9xg8Ydx)=WesgUPiuKe
zQKPrnQ(jfw=;39tOKx0L=F4sL)>JimitUaSlKaLoUuK5e?W=F~u5>qgnwR<N-JaG~
zZ)@q*H7Eu89Jjlsqr+~u=Tuj<HPnEE)`sR~)$Mi8nlhi=UQ=Jy>h`r(HTc?`HIA|>
zd^rSZRL<vh8oVeRjqS*(Y4lXJI#817c6!_B<E!$a2RD{40We$Cu0xxis-~DEIFos3
z!3}IraVG0kZDZ+*CL&XQ_GBQ5eD~sNbjIUxH#E0-An2;*T6e3bx~j3NxyDmn3SxN?
zlxA<OhqYOj;a*&ZAt7nmvpCOn4UL{SGNN94+dPcVMP=T6cZq1tS?h2tF7uW%QdgJx
za%z05T09VFUai-?vZ2<~?4U6LpV|6|H8iiNYHX-=SG6u{Z}K$z{*zIg14i0bHP<*w
zYnqtsXb6S}9Rm=rLyRedWEz@lT0M-N*a8!x%8llJSZ~foj1dK%v&`c|L<vcuxtI#M
zcz9qiU6?MFyUR1&j<PxK#YP>^<fF%R+*y|GF3WM3+uaTaUcq(w5+m}kZ2r}Ra8TWH
zV_kh>@Rs81H=j^cpOkBq#ER?=G33w}Od`@p%u&)l=*^slHn+D0YC{tp^~KCbB>*t1
ztN6Sh)v<q@IYz4*wy4=%Q{}6v=goZ<%aOr&rLO8KUR_lSqHR9WhsaDXVl$n!T-8V>
z&F67@I%+&Ez6Nizkk?sE#%v}a2$58T8KG++u_nxI(7;r)>z2ih)k|wt>ncpv24cp&
ztfRx-;%RO3He(9<R=HPXeD-d0tHq4oS@6s_BMEuA;^_7xhW^8#L~N44b_&(cb(daU
zmgR0_Tzj)x+I`HtEHYXih@^y@9@cGLkw$5nn2Y638oB6c%^S$6Yiw_;k5D)p+b*a!
zuhh+vu9$J$377xBK+2}^bC4+?p1%>>hN;epoQ(l8%%fHh^Pr-x=$rS`{8q$z4ZB}&
zyU*>dbGKGCFY`nUx$Xo%l^8bzu{0R7J~9n;!JM7V;S93*<$)K}=QSD`c7e5?e`)B;
ze62BkKR0X!?fi^}86pQu`MR}e^e%(_8;)QY|8?Zihi!wWqeXIG*SxX;-CFEvgX6?(
zM&MDi++9<@++A1I&?rGhK5s202#QeL(B`el%%b4O=f#X6V?d!01!GNB4TM4Fw61|{
z!EGL?$<tKR)WVXMRVV~Q&0aUNQe>S_yUkZybMeKr`H@T6rpVi}8W5(Oo!~VbzR=~I
zU*yhA&&-z=78SX((laC-l$95G&5pd;hhMXXUo+ElI7USUNMxsHWsb<&?IW`JQc*=k
z;e4mto}QI%%#6Uw98n3;Y6A9h5)A*Dk*EKXu(vb}H)FRj5j#BuNfz*N(s*eC-jnbj
z$K*980&W(y&5{YxaSFpQ;oBt1tcFgR*EIo#9V_wQOIV}m>n!!2`>}FJk-~t{LpVna
z<)t%MO_0#S`0;wVS$a>DR|2%1)t9AnP);<bG&Eo_FitvO<nLqUW2LW){5F;!BV~$w
z`?Lm7OO)m!Pmc*QcvjG-{QT43!^&f#<P`W-EI&c25P9{EStuVbEfe`w&piTulcjc%
z|H~uGvEndGcZ&S2tbURd6nWpQd$H0@kTxOD9<jawkUc%Kd72yrFA(qt?h)lYk@Wob
zyEy>D1$V<wuK_-F7%c5Kz|#%zegoWYfFCr#a}DqT13b?F-z@mVa!nGfvr>H>2_dol
zM7@f>{v&vy4n(T2{|GLYe7sbw^9W9Rllr5t{|H{J1Ci?MT7q9;fa~j5g3mL+_4O;k
zBWpms>+4s77vK|ldiWc*NuX21PqG0H#fdx?16*IjQemnAj-_biu^Qmiw*I6U;57F7
zlVN}pPx_N*fa^L(Wd#N}rbFaW3~(rV<S8}4Cq|%>RAGQ)Vn&`y13V=Hm85zDTsFX4
z3~-A9-eG`GHo!X#aO3{T1_S&{2K*iaoc7K2=K%v8yCjikvjKi?1d8((16<z&q2jFu
z_*V@0+YRt(26(RlKHUJ{Z-DD(T2$O`fQzFmR_mYv{#65=0R#L316(t}tp@mz0e+zY
ze%b)P$N-nbd?#J|ngO0{fZGgkivd2v08cf*XByyE1N`d-c$xv8W`JiH;Ij<yJOlh<
z1H8Zhzr+An4Dd@0@KOUj!vL=^!1cW*Dy}rZvkdt426(ms-eQ2~7~mZS_#6Yg(*Vym
zz&9A+ml@z+ynZ2p|3m`s$Y1?X@gGfA0_Fo=Nm9CdeF@=y#s5U|Zbmko^CZCG8BgO|
zzMueal&`0<&_Ec^j9ru`R~hPO`5lxe7a8hh`QK8WTw`b}%m0G%<Pt-hS^meACs!Ei
zVfhCsPcAUj$@2G7p3G6Gh2_6Zd2)H7N|wKq^5p75r7V9N<tcOu6|j6O<;mrRGFbkb
zlqXjgva)<N<;lf`EG&N`<;k^$B$i)Hd71J<X8@RS73D3IA7J_Ul%GubewM$C^5nWg
zy)2(ed2(5ytt|fy%9E=KZD#q4C{H0>sE6gJQJ!2@sFUT-p**>&Pz%eCr#!i+P$kPJ
zP@Y^<sFdYDY(}13QmBCCPg0&-Q7D7u-=aLZppcd2U!y#^o{)v*|3P_jIU$MVpQk*z
zn$XZE)c+?bZ>9VI%kQE*xt35r%kQ8(xs*^Z%m0@0<Vr$YS^gK4Cl?ah%<?~`Jh_fg
z56eGDd2$({PL{uy^5iN)EiC_S%9D!-RkHk@lqc5^DrNcGDE|%07qEOQ<;g{aGFbkb
zlqc5^va)<N<telcSy=u?%BNFaV)@0Czm)PrAG7hNJh_U{0L#y(yq)s>$Rqu?9xVVN
z_b9=+x4R@s`!!lr0>!rETIJ%T8Pv)4G?X2uvflzRs%$dKo~N<}sHaT^f;JIf{>!EI
z#9}o|36wKRQ#hq$Mct<zC8Q%j?}?&C?F5L{Rk7RgQrXMsq4q!2*iZ2FY3+1TJ9hv{
z33S;sbY!?kH=w0GSA$w7sQrm%k}L2N+ZLqSEr2M&oMf~GW)*dhwwiGhO=7wdm^ywr
zkb*fE*AwmuEs+{bA=buGtLh0w-K{kfJ^yN3h2)#01dzJaH?{vE;3%#pDe5cQv#jdw
z!Kbt*7}8E#57<)jPxvNNjm?w^wwSa!#^-8Vi?$Ing(#P5cf!UHQYz-|aA(tq>`Eqw
zVPa2=Aodjy8~ly7II6`TjzD_%BOq;50udr|*X_{85jg$833(V)palib`TOK9S2X&M
z2tAje>MM#msND(%LNkrk^H0cKQ=_YWld6T;uo##*F2*S$q9Q^&7>%|s8tptn`%N_3
z=4iC{J_OpgqtRAHqdiM#HGtNo%NKNEv?S@%-+BtKw;$L+-m7p);dO=O*Oe)2kEXE^
z4Dbo4sC-E6y-IMkO;Li|Y!AS@Df_x?J>=!^)G2cFi}cl7CpYe@>!~xe`LA9Tb-&`@
zo2>L{Usde;m4;rAI<_%5(W3ZwnG|)=X=Uw)Eoi3wMJ2e2E2FyFRtddNaKa(aDz=qk
z^y=gjy~L0Oj1%_0Vw*yYDR{y3;M{i73m&S}qS@eKUBOygfug?bQjciw!XreqEBG)|
z^+I*;Xw_f-K{#CaN0OMM>r{II38h6_2miun!Rlmsi<$*;_ih9L%GxJLvc;-))6&A5
z3zrt&Qs~}|o-72fG)w4;fD*XR_5f%rfo-g})H7o5J+P~@SLc+!wQn?I&!2`S2Xj7J
z$f*^53bmgbsGXE27uzhO$@w|CUkh^YB4UZhTtzgw)Y0U!Ik_r9?x&wZZd^1u>u7Rs
zyw5s2MUY$aDdcuALGY={I-53{-2I%~z6D%%V?Tu)ZHwt6!N_HdCby82yG@YWPJ<t3
zV9$#tmp7W+=~Jw;vjw?^8072+NK4!XVuk9S(UgA8DZSy~{k$M9rKuw*Ju#Y6Ehss<
zkI8o(B5lPygWh9G*iR{#JY*Q;3pxpMQnvVPdH8O$Whm<LV)Y2#Yi()xzS(AlDmU-L
zYq>2I-!7X)yBU$}Nx1^_3jKRcOu)&G{P)^_zk?hl`8&b;m%zXd3ey04q*(Nax`&yx
z57To887GvD75IrLLmMEBIduS7Cky3oJabaMrB8c+Rokcapc)Ds_G6j{ppcb3lHRq@
z?QjIzuim2;c86Xibw)Z9)_~F?k=`WI+eG>z!`l=3FOmO|NP9&(1_qnzzbNwOBR_01
z<qITQpV*H%)#q+e)YlaM>qDjG4tuZt0Ah$j;D)DuR4qyG4p#yExmxPD`AJIhPy41~
zY4awKXlXMpJRrtpw@88iBZi;zASJWTDC&^Xcl=7F?{uPK+N(Tw#y157ekTYdhX?B9
z3yLL4uTT7S&RvSSQhU~Qihpi3Fd@Y^DBzfz3wU^HDL`5cnB8m62Eep*_b|VpQy>`}
z2GI*G1Fqn&Oi@3=`plvP#wvjV4Kr`-5H-*pmb-c}7@c?INxrYhkFPAEfxqP>#OZ&+
zg5c?<P~kfy+ts#Y?c8_qh9D*RaatEC!Kq`g{@@fbd;5J)FnG9Metc+fJA`iFr|>#g
z&}(6i5vxR(da2TV3b6!JgHIIoeW&`a)<LbRyA}UwdF3VeHu=tju-kK#fCG|Pn!GnD
zRiYIoH~YH_<wuij8yuFwSCn9fNgL1DTne5Yk`t3w{Re_H7b3dnKz8u4o+y5<FI?gZ
zu1prrnyp;D76mi0>vz<*z#6L(SeoWkUj%0*>U)FJ_;@+hV@jZj5Pb_HNcpdzHK)Ab
zMWy?B-$aTH|M+$|4A#$e&H6}Li_j!|#~pj{0?M7M$EXLpdsjUQGN~Zb{)dwM<Gx}i
zH8z5d#TjU~k~O-O(@J&Ddd0aGq(IAp7e;Ghv3k0@x5MmGwZTLeR4yVO<`swaqj1S}
zh%COfhwH)aWYUFNB@&xpI@^1-BNPYaAM{<P1nLX4h9Me`H;V%>IJ*(Hs3+7!%?D<b
z%P+CXUE3k=K%)QjMRM0Yc*U&vO4L$dDya|#>z3VEL=3)0k<FgLL)vdZq6hp$v2qDp
zT_|d!Em?g=yIHW($XI##1Y>0fsoh9^wvo;-etL+X3H}ejPXk_ekbD%=E~W1+tK5A(
zad?0@9I=!+XC#LZ;>+4OV6P7GTqKb5AI&56x3al%f|>ea<N^h$iVC?wMdhw$0ml9Z
z2SY;uK9)eLL~(%tW5fY&6yQ`PPyxsxxhp^>Gq9W#LhkAZ>#l$&wWRxXxobK~N&-F`
za+ol5U9u$5jLb3L5@%pdY6%pa_A8u$I|`h^Yf4K<IrIPQo8$~EEM;qq1PmiettiDL
z<s})cM1xcxucXG*uyzO;P;LK(Gw>}?S^`SVp!6b9TEHo72MS6-X$dIt5>Dx%VM_07
z_i##bR~j*^9uHj&{*=J&1xm1}6rBXsePq>;p*2u7&{1kdDX8)iPF2yVl1aLp(9r8z
zEHOgQQE1NWC*~mNI!Ylgovwq^9na`u8V4OZUA$0>L&rtGX}xzC87Al(!KF)mBXlQe
zUchC;;H(1aLa=-TBYln%Kn4V8*weIMpdzUg@NPpR^I0Rn!Ak^Z9m82|OJ!o#R#LY6
zkk6~AH``J}A7DABFE5-hs}MWl@RC3y^aX-QaYA!=U*@4AVL<f7@c()t@6LrN6vKE#
zn}Q66QSLg7Zj`7;+2#p#2P*g}-AUCB9pl{rUYzcvYQJYVt8EtEoh_6_cg9n9ETJ#4
z)hXr|C_r%YA-EfL!674rV$p78R9u9&3W6)t1&5aiPKjtKnYT30*iv%nUbe(_(Ioto
zJ|$~o8I^Lvi_@oM?eJ0RH$=-@`YUDiK3PMPsU`mtd4`n+*E_NguA28FYrWH$Ml8xg
z05*9eTYKQ;C$>%w-)7s47lXm&I}ytE>-b}K<qyesrb1;)$QQoHCi}S)CF$y5QZ5KJ
z+N@UvFUi0gB(3zlk%%{vG;L25Lvhrj+IVnY=s$y44`E<3z6leB6?jE;xobAaxztlG
z^=-D!d+xa6fAx%FdRysxHAyk`>6&P8+J;woGF)$OhCI1o0G}Zxe}DVY!c+T9zVpfJ
zz&=$d{(&<}FsT5M-d>6^C3$kv-a0vL7d}to^BNh#iaPmvv*mJPq}HZDKb?VKCpI<7
z?VI+nPL-aNm+n6)y9ZcjEAicEt3N5<{3_m{#`vzaC5PUJ31uOVeB$+!iu?_PQzuR#
z;C)kB8}?G!`VV1}oq?o}mEbidr@GO`o7t!IotU7875i!080tGRcI}bQC71jll9$&W
zk)*vR^!$l)@Fs7#3$#dR)Kc$B`3Cb0oSi_flV<aD>Liv{JV9lXISgE$ly~h<sFTZ|
ztCO$WUnehl62<67MJ+~V?FXFA#3aV%(@Jm^*xV`D>{I$e6VwB=lvnZo>e#ifayCU?
zUi&I%ljlQVbHBV{A3DzD05*s4f<V3E{fIzlz4LhqWG-)MSRhky$V37;kEc^V&SUG3
zy(AEc!3?4RA{?g>NFQ6KSnA{{0}-Lz5AtC3a}i1_yik0he2mi1ODF?S`Vm?Z#)%vW
zWh{gtPyU+X-%ZQ2sRImL!DRC~dpF32q=MN3soVe=aoIrUi%u)~gL2n75KKf$L!9@|
zLrUs4GIVO6f53zuyskVKQpWX>wv)QP9{M3lg}+tzahzV|xf9B`eT0LRXGL#l0{rK2
zycwZ&YM9pBz&jP9&9=H8%)U5uXz!ZJ1uvuO+eCT1`b&w|9t6(JQdqT<*wc4nzmw)a
zq+e^ZhTcF#F4jfBlV{c1$g=uuR&9>~8Kb}ou<*8q4l-X|0K3KTt=jh)CO0b#(;B*p
z;dGJhBRocu2%|}@(Lfkn_^3t3%QwL;mL|je&NmPiIR6~MuVyu1gg!!}Kr6PTV&D#(
zES4?i%{U+~QQrV`r*K5@2&GUcC>6XyCBDg|7RnW;T>+TkI{DJm@|_p4?V_8plSg(M
z8xZ=YpG)Pt>a;VsfpreuGrgk(FFA<LVcQOkV(+U18Pvu%HZFiRa=nE%UCfNTY#nH?
zPxgNk=Ey<I&jMyk(oU*AY)A%f#^!qPC$_Di0ChPDa^=kEV-P@No2?TCa3VQR;dC5@
z5G0EO>tstJc1`42U81U`$b#Z7TQBfW7Ri=NvQZt8IEcc}U~XXm;8`%kZb3A!UGgRq
z<BXdb*`)*EaYiZL<@G;4!b;{YMh*l01njx_7WSSFsdb^$8R%xtWiGeqh0J)B?~#<C
z0+TNMTR*mDC#b!Oy<btWD0yw{+Sj;6-=(N18<1ykgU*ZJf<fOUZ+L;*t^+j7U=`qi
z<cj@~`F|RvO0W=Zu=WuyJ_AQeE1n7J^P?LQ4a;j^i*Bi3-r(Xb4IA_#+)9ANa<X_@
zP9s}ER>^GVkV!n{rVAkj^Kj3S>B0xhUOy>~A?|v@43WY8U57|u3Abx7gS0huay~{V
zyB{Ou#NM^je<oG#ro%@N=&})*EGBH921dGU12mGlCG4I6JcJ#UD1w4ukBf^3GppsK
z{0*|LY)V`@B>OwbV$cR~fGaXdldCcYzl-k^^TQpi5BcE^+5vys-q-ZaF4~LMz(C|g
zM($380%I?lB0ocTsP6}<yCU}OEoIy;YI7HQ-5dI$uz&sj*NEo>%5$1BuAj>Hqx?W<
zDl5mv1$e;Z)H0zMLc`EkKtex6e|WizrZvNw$gr5M0gJ&I?mwALD&RA1GBlITZb$I?
zaN!>?<PsT-``CPS1q)K^9P*Us3;kgePK8Lhu-Qs8-l^^eQGHr>0wSGs$d*ctzFUUq
zyW(`A|3g%}1=Sq+f0pmM4ljSA7C<xYY5Lk*C|~noU7?)z5jAswzIx&H!|G{>;S{70
zoLJz(3_&>RqHwgpxPOHCjoD|ZutGQfOp$0^v79!DuXE}LK=bBjD6gS#055w7P1H`G
z{N+lGUJlmDH$OpGFV)F69KZ+d-f*Z+uGoza)b-k46z<xEQ0*fY+1^_xdl9;}9Yl=s
z*CE<B8NyCN0foC)`H!5LA54;!2Z->S6!1EONxLD&o2>{^E0gK10#@dR*C7`Eb%;#u
z>-2T_q<rn`FfB(F|346{_n8X)Z<(C_-c%A<_ZE!2qH>W#-afLI6@2A@QARfOH*8fF
ztNRDn(y*Dg<1`sP{=i`eO(+r!b_E+7SbEA7und`bX5sx`MQvz2U!9<0UuY(G9x+<_
zCG+@n98_Q-GKl{}mty;GWc_D=rM>zJ_H)!B!)7E*Ki@xbs(-_lpQ3((y`Fcl<&^3Q
zthBJT%|Ai21bYc3fx5K8)VdyLU`Z-=W3hjBtqY4aSD+euZ!eVOzu{6}!_L~@s6=+D
z*j9Z-t9+Slu6-GsUanaK%3K5<cii!~G8ZH}S0`a_?YE$2Vd{-)?T?hGLtO{jZyiZ&
z9y_qYJfeA?0*WrUy=3fS&9Fb;-RqK_yIitz5^KLyEO2gesk?^Hnn*QEW*v2|MeotF
z3ooqc%Zt^4L8ue$>(bt$E8s{i$=~bynoE6O`#zcgBd$OPI#-F#?F}tQb$!(Z-!*tI
z<c3Y@!EYmFn`41Ha86iMq3?=R(E3=*1R-ooPggKMgSTUAD)FY!vw#i9Uc_Jg`X^sv
z^$*dJ53jG?O(fM<9<N6?ZVEjI1nkc_)iZo`>k4?$m9Im5zDjhC$2U&wQY1SA=h>9}
zmwai6*8-P=RkqxxtsM(vbv-rZ-;Hypm)c)u$XHp=b;4|0(3}&pRc5`cRRIgc+aE3o
z%*0NN?_y_Qg#{8nveY%}O@6=^nhP8zSE>YLxtop=2A|Ol?`|dkec#p4wD<U~;?d+N
z`w^4BBmXq;hoQ#Kvc4a0(B@&m#(ER>-mqV|_UHx*rLbiPDLiazF_SiIv$bHMhxI!4
z0L~LTottbO4DlToLLY1<K5Xm60BD7WxVxhB2^<5N`y4d=x@`P-aMCZ>SzQ;SixY+K
zAX`_A!{t)YA~d@5M2F3+J=*F=*rotRkD_i&;_yi~5g8P9fGt)ODAZi0A;jfc3yCFY
zu3A8h@3eI?#yLUk6vFtXG5XXmbh1O+3WnL#JfY=K)j-ycWRRp?MGuO|i||HoLksV-
z9Z)ljiv5(fj<p2O%9_AM4epk;ul^$(-q2<H9;kF-zjX09@EYv0(M{^TJYikzMLE?O
zq7)9AwSqp8OQwgPbZknh1gmVD_1oYJJ$t1XGQ)1PCeOlgTIcO~5_VuwBtKqOL=iwL
zoz4?cZ3gQP_QV!zfntl*KVT+%A$R|P2>EyNmT<X&(M3PNARVx`P)Zk1Zni;Iu*6#9
z-<eF`E24f=FhYDY^niIkv7>IY?Pu<JQXjHBlI;h8BH95e06rrthO`$jdf1Rsa{+TF
zDzYI(mK7ydXk;%pLz?LIkI*)?4Ci(;HW4AGtvaGkTMRAlMwe~7-VGik$+I@uIsqb<
zdPKSzsdgnB<%h*MY+_PDgH|Xmu}yVo_zqIqeT)QBDc`pXBSNM70R=C;Na&Hj+iTsm
zq1>j(-9MZTeE&zXy#Ap{><#e+osZH`b{BmKFEH7ain__xkIMD~_U9E+SG=>6A{_l2
zXrrE_t)o%E02j~z6Qb57Ah@>FWwQc8B^FA-Qz}w=h|SF+r84Lsp-S3JHmY5=0uH1E
z$i=o6s*!;l(@IJ~EsshGft|lWD``~O=KnM}E~bR{<A8%HA(-LSSCazmC7M?40mkdY
zj1X;we~AKGLM!aNf;RXzvztR$;}D$qR05k=AK-K>u3$@Y2`#s(ai@^Z14;tkG#3uG
zzQX;L`bkOP4*2G<Pl=S~54zO16nVj4BIjCfyue&9&Z1s&uKk3$zdd+CuR2$c#f=O&
z-`{}_&L_g{+nxEx<*r0@$rWfybB!Q|8O0B`?&AcfDe6JjEKT_GDcqOK8~0-3<G^IY
z<IDg!3Y2`v!FQc2&|csQuEC~17e-0`8M!L~cPDXVSBi$@JJ+C-bVhO^T>v2wIsKnN
zdls=R(D%_R?J+dW=%`If(cYwVrlEAdl;-acn{aIYCX?(H?cu+%Ih0cXMSC7*8RN^4
z1LpCCVp<_`Q<8{>Nnv2oBq>Ff(n<oO1|uuxZvkNR(ER0ab8i8%P?Xd9)E4u10IXs<
zy?SM2{?_vOn*ny|iO?4Fmv;jiN8KSa)WxpF$+Lc9!=E}amMkK*BGvAAku}hQo+uD0
zSw65)fFgRRI#r_?Qb8%SiYzP%rk)BF0^;as9GjT;o{JotwRsqNyg}}D^hUGxZ!%sm
zYf*2LjsC4Beb!O~`m7~-qJ1`N`$_hgwd~RqA!^UE(STqvvJQLLeh48jak5pgTM9Ty
zvH~eRn6QLuxWq;Dl4-6Js&)%&ftmSJF!N@)yBsb9=dp6vJ7|xDLZlEcVQ%p{ii&{e
zI+No6gzOU`;nb!3H+aFh^q38ZfYjwUW!-HZybt#e5g$QwUBP;|`Fb3D&?Hss^XLK$
z<Mr~LjCX!LkXU8$)55>9ana@y3p=@-(MzT-#-YA^wXL34W#dCp;zX*7I$O|d=*}^a
zz~PoYl-dtiv3b!vqD+zvOuCBRb?T&~x?%>+R}uq8#RMAZnD(>hF^TdI`)ugn8nolk
z13<hG7wi54F8q5~0QeHcb}5Jx5ZNKH)4oY%;E-mgf*!Q+9*_-Xb*~cT7FNE~wi!L)
zC{`Wi>x2?C@4o_7K#8n9^`M1PqbmdTN?!G#UiBzAr#cUC`8-1;P_+}~S|@ASY-eI8
zXAzh*o8EQOLO86Mp!p)I3gL91Dm{dz5gGM4YC=RMy3L1Lv5Byrt~Q~NB0$5QLII4J
z)=Rv>Z*O5dCMv;651qt;Hs%nzS&)IV7rE;?)aSP_)K}=jMSrLWkl_H8`o_W{XjU&O
z^6pD|_m2^8LG!nm<PgKLzLAv@VxyoH<v-KKf+B5IKe4=%?FeY+anXMlM>$Gxr)|5i
zaGiu$!1y+Qz=%)!kR>~9o!}zUj4nc|hIkAoCaj2BB~b!QkG6m{IZ8^?EHGk^^7s%t
zFcfa<3jtgOWd2Nk)FB~)r11{@jbyF9sHivz)D9C#HIYtkt;{wq$4oq>Jq&Qj`Eg`l
zSa}@IjUL>p_`o&mRk~l<ciODrn64`y&IM5{yS%8VF3^!38ji1&?Yv4jQOVz<$O|<b
z)S2mw*~_{CL>ES!3<*|$<d{lnI81%cV5temKd>12PTYNw*Ix<;Py)Z#U56L4CWYX!
zFc~uqaVq5EQU_e>$-#>a=W~iWUI{25aTTms2MkXydUqSrU6_0aeU(bE6;rYU2$@PC
zS;_yP{Tae@1s7ru;&ig?uK_QGr+Sm*?t2kNIIs|YOnx-KV8c8B6MVmPsJ-*$-@8m_
z>gKDiF=wdm;DcDFf)6HdC3vGXYJ#hO#=0(eMS6+)ZYYSY2ad;&q6=aAoCPebajMTS
zjeZS-&I99@44V$FS#QW)SCX1Qj$a2w(v$6w0ZksBLar3d_hJNaZ?;!a8!Yl<6BE{*
zXtqRs69#zjLcT61X*w*}ZnV18CWvQ`)s_E_+_jVt1I_RVYjE!-S5enUCBYJG&3q!S
zoI-)bK9~BWw*FbHIk|qh)ITd&wc#Q-_S&?&P~bw(O6l?uv<kE_46OJ`?OLi8)b|Ag
z`HDKP7$^Z({%O>ncUlSFma6!VoW`ZGLM*^$y<O-Zz-}4_<xcw<I@29EZ9i40zU|+e
zyeKeb+#+>~T%5nR^;qajDAm{FOux4=iO`lt1?eTYA&r0g8Jf4q(hdg-_Ho^Z{xSKf
zCg>LQi|!hbGHX8qKB1OUC2QzTgn4ux^NN;=jwk`LM=8gn?a@{5Mcbo1K!)wnpDJlS
z*MT(M%?iSbQG-s^0jGF7yeLKaTWR{k8<n!CxEi|eQa_~IR5GfS;6|1c7d@OR-O6$l
zIQKaekdzAdI!Yy1{(Ewlit4xqlEy;I{KMEdVk0EtSGmg$GePTD2&G;-?`i4_-snD#
zOw(*bKFX<ijOiKe<EL1lI}KA!nRPHaF1=+ek4u*zb-}xo`k*zA45ChM?`{x(oH|U`
z&+bGfbR~o#=E)`&Ou2$h;Dkq-q-FB@JJCFkQhPBK=?+KtjTH7GFjgOCG2!0gv@p~A
z46++AA(vyNA$Jvl2_>*mM3?t5R3-oKa@Qa$*v3{TG(&LGu#vf2`O95A5X5#t9?>Ep
zq!TtK7mt0nF@(KD8IA<<Q79OC=pB+8ugrS-Q-~?FfuI;gZ9Q^Cf;(cwotyZYPyGk3
ztZGgwMP(`tEr3U(Et<eetN+;~Z4C+OB(6V1^qJ_*5%gGqNpb8Z9)NOsA3VwFQEBL5
zCg1{COJ?^e4hnsT!MaFGm|G!rrzh0=5jE6F@9YwxQw<kxaAbrwLDltnO6w7^w<zEJ
z1`6~w$vH4a-Myiw87^7p!VP0aEF?m|g*-sF*k*zUqIfkl2Q!u1A7=Rx{gESg&cebD
z@&Fsk_Fw*jKQO3D--n5c{7C=s?GPn@7Y2y5q5Jvm5T68(vr94cD?9Z2Be;GEkF!gm
z3mAO^i6ZLPfU3QHfR9Q)GGt)cF3(HU@<F0Byur(C?Q&sj9}~3(2nVCa(~Yc7JahX1
zaD}<ONXXG>Zym$-b`4<$7L2sFI4z^ApXb5#F?-8wl6DRlVdiM?56s`d?i%bIx4$U@
z2iA?-UuKJig>$L6Bf6D>aHGFOmss~Pao7N`u>4_u>XZ+=CwIL_J>Mb51$Ug#@P1|z
z6@LgDmmlDY1`X4b$`0Z7FHkOgPVV{@vtrvgB@8C60{f4n=Vz?)I`*dt*!EY{XBFJP
z31+WQ`rgFln=?J{$X>;QFZ{tqZw9<}2Hp#X<jITs<;hnK$dl*eU}C8K@2C1qzD&jk
zHaCbr{n8DMd2q@YC6OPTp>_f`tt^UK3TKEIE6GVFf>Z$KwtY0IdG$TGav1haaH+?^
zsP@7>no@#yNQm@@x@=KQLyCGUjCMnwq81i}ilE}mp3x>>4{DJmhtk11XM`5OnX)C0
z;_pb4eC4h{fz=tP$KMMKD#QB;)10&wPRjvWUvJ#YM;WH5eY!I1B}MEmoQoGQ(J62I
zA50_|#SK3~O8d>Uy-Ig{&uBe3gT?SV)qV<^x|UP(!2B-g()Rm=PAqUFx$7sWNVm{w
z{-8E4A-|1nee~R=9@94NiSS&IW(wWSOi?j<Kf(?i{{UEXiJ#ReXi9w<c|Nase=o03
z^(~`F<yWjbw9Vg(K!jY8*hQI!$ccJQ?yo|-AFVR4j9#DTob^v}q#)mYK2%CSR+xZe
z1!`;@!TcSm=*kSd>RoZFT4*-%!oH9%S!V+K@FnNV>uEvrC;F>P?Jcwg>+=}h^$+y`
zEaEY&jY2m<WTGEnzL#VX@dOBF9%fd|8T8o@E4-z3QaQAP+(O6=5nx`@c+`igBXqdG
zU%}dB{vKOR5tkoI#&v$t9>V<ra70h&zG1tp%M<hP1b8Kx9(aO;rEr-(g?KFD*}qE|
zffmRW`_Q;%Kn*EcKEuZwMP|&;H&L(EJ~HP1H6+JBu^3}d=otcu9wA(oyS9KG5&?PI
zcjRyJJ(*E%Q}}P%F=87e>cP;H=o$Gn#dOG-|B`&?lOW^_u7TVJwR$k*RG+|Zl@InG
zcUIN+nG>x99A?v{;?JNk`M7sqTFOFzMaSS6EASP_M+mOYn;&qQKBf@-V+z4TQ*b0l
z`|Gr2M4NODg`L9sz_!}&{}6Hg2E3lyg|PlZya3~C@}nCWxBk}>Hl)biPXHWgRi}il
zEQ$;ECVd%YVxWg;6}26XjGjBl-;<>L><|6^#DE0G-(XBZ#(pfc3X3T=d-n6_NxoYl
z2%kO4q|kYk=L3<8)?DhI(B%Ljg><l1@?fa34S|U=at`6IHd$!R4(}B0+Fiq@;{w;L
z!{WldeD}FTpI^F{HzpvX9_-UD0KMeU$Ivu{w4pQ_c=a@ikl99Pv2{3THTVk{R8lcA
z&j{9c;a0+Yu-1xOS*P0%D=_Jy2cY}3C?!qUFeX~0A$GV6S#m{rMN!A#+DE{Zcp5?X
z7_0#nB`df{>3<c=fc?s>eWred{cH{3hRA6N@Vxqhe-{qolIFP7Bzyj@))S#(6w&m5
z390=1^29TBYB{aVgbs<(49!L{-l=8v%YpL5kAVgCiNYESEan$TA!6*9?C9g=<m9nt
z|Ng~DFhkgm$s!B^4j{q=3rvzO;YBS>wfIgFz2kfr0cZz<vORe7o8RD=8erNDy}W@T
zY9RKuMK0q32Q=D5h8(>!(6xmKl@b<~eDg_nM{KZQsDg9pKwEQ(#s;V{1gAR>Q{#F}
zkO!yOz6O4Qq{N-zPNpE*Hc_vXdJ%iq?jD8$2czx7yud{)>`40xaakXRKx~j<vA{RT
zJivAO_gDvU6tX+?12&#}Li9I2OxfU)i+~Yo1t4m5eX(GKS&JCkXA?xZMKHP<9gW&P
z)4(3t?KJwU-Ra1L)-WBQGrgUxx;clBXf6^vWNO&V(oYg`WtFyTNOL;T1T<svED|YD
z5eR8rk8`<>7zVk!f*Qh-@~3EK5SqV-{i6y9Aha4(c)SvnXzjFsaTqm-a`!aU);^>%
zbvM=C9r`6R;9`pu(um#;{e-a**$#a<jaXzcFwF|>F4m6uO5!{)sX%mqEqe?*q4YN}
z+!K)0l*q<&(EL?KuZwSr-t$LD(#$%zN4t;2TFx_}-NMa83FB%42j_0VA(yrdm8nD5
zgel!Km;&V_KY>4C&li0l)eC(abp{U;CbO!*WKv|B6U0!^sAE)r_X?V?COa5C73A)}
z5;!>bDx8UEYgn^;LQfJaqfzNk-L+ZNJ{n|;A*6qajk|`EeP;s5&IDP+9D{SH9{V#u
zjPTl>AhsIBLcbm)iU<#OGUKF;C2oC8Si3{NVC1p2NLqy%I&FYh!!EiKpy}zGsLzlK
z(Fmf8kOvJTsOSPdYV7O7cPCmQU-dl;Til+eg-eKC457C->Fe*<GdhM3uFy0d8aDl~
z_sJB3BXIAfxV)zVVycr5;rid9XX@lZ+-LLRs>h+Ha80P+gk@Df2eb_(;?59C+J?sI
zFS!54A#}lr6#<7{ytt&@b}9+QblYeMcmzFxkiQh+e!twkg0vv8o^c=eUMf2A2iBo|
zSeQ$l#QyQeG1BZX`_;9$tcK3c(2HI+_6%3da5WHD(v<fPD$l*8WPPs#2dFb%*_!-c
zbW<?MvWm)^3a+Q7M*IQ#D0v)YA>99_Ja$FoL98o*bCrGT>E0zh#=ej4Y9+=l(p7am
zRo{(Dk$<zsum3AGjMf)lUr68!349@eFC_4V1ip~K7ZUhF0%sus`WK$*G5%h|W!4&R
zGya9{_8R&L0Bc>Vx5?Vv-q>huXtOqZeOC5U8G?3ARWpI`&zIwO1FZPRxG%eGg{Q{n
zZM8Pyw=_JhR$qNpv$d(J!`+5|&pQn(H2!2}WaiG!u+O$<&o1onG|pb!Ufs~#Fgw$p
zlb4a7kAE+m{iEUD2C3SEfAJfQH(X|Iu{O20`K;9*YeTd3ri@GMOQn{o)~Y5Cez>JA
z-Phrh$|Xf|NlWlA4;M>|r4nh8)QW$XywS%?i>wmo?Xt`8uknLp`ndylRSSNnpjPJ#
zp*WrsxUxmhP@zb1U4ovWE5G}~Ol?B?<aq+`4i1+(MJjQ4Scgld>4}#=jlxuXdVh_7
z9}Z!^^|#@0CDNHlw;|0$+Ja$t5GmayHT}PE_$b!qJCW96F~0eC;jjg1!DCo}fldJy
zVppJEFH+i-DaAsnA87$rO?jx_kF*DA%b&vGY%G&|c89|cfZk?YXGjCyR-_urhj5vs
z6XhAthr^qYwjkY()cTijIEnC)W+2UYCmilVO3xIYNT%BsOQsHsY5K&m$vvP+@bmB~
z-4PDYB%I>0*shTz8$S4>D{1?$Knt{`6w88?)T`tPE0a5=E2mxljV#+mfJ%gXGd?YU
z#?=i1;IZP<g3rgG*@{#uOtJVA7N%I6$ER3|Q<5E6s#3f6;j?{fI1CYizSWPeNqP7@
zj1S3dEmCQIiY1tUrZ*-QrdZb{6{e*5&BZAh-x{Bi20&p-DiG$UBo~4vjTOoHo1lpm
z2xw;b&FhjjCI%CrSNM%T^tS_a-=s2ByE|ciO6pyS3sS7Xr1>dn8_k6&8SBOrrsVm@
z7N-;>97xFn01eJhu>z5|L$adBbX%#5NpkG>r(%bHx-L(W8Oct<7~hQ~sR&X*)w>eF
z>N;x6pLBIfMuKNNV;+*>%oAOb<Bmtd;bl}$Mm_MKv@Y>3k_*vYjZYrvK1Ago0Xj?<
zqTqB_$Dq3n_)qF|>2H<|bQP4H2T<=b;qY9@#~>GUJDB8%$fcO%vM{AIVcYnWJd8l`
zNWoxGi5C3}qS@ea8tL7zj2W#_GHyvUCB+gls?u0)1Fd@8fyl%=*P+IgWKq_SvW+NX
z6Q1eUDpp2397Wkylx?MYOh%5B)L<fb*hu=bj>g$PCSe6ss5r%nGT>kou9{HFbSg5|
zX{eruVVDBlzLsb$NU^L-C{9WBCqkLqQ&Q1xVM?;H8@mIgC?+}919$xe7@y@3=BM|6
zVM_0$MDGMhbF`W*fI73eMf3V6$HU<ZL7N_Grwi{xuoW^ku#ygsXvYylmlvjNO-TH3
zT+DV9YR8JtLC~D^>u~rnyeB;XnyBO-yKc-zb1><y#Jdxy-H(B@0dwm+n6OFT*4uT`
z9Evr*3sVLzNxad-wIymA(R5|)(w)>&Y8T{^=<nB1$=EK?V4F?!Nj~?&`O;FfJu3hG
zf0|5xF+F86KRZwQ$Yee;S6Y{lePXWkLZbPH^Q7;a%^zJR{dBDP)D_b2$C}SvA-y-&
zynC*6INAKi%cMgS&HlO4p%n9}%cNr|=0D7n{wSM&bcOWPlq}SJZL0a_^GsXLHUISr
zX;bPm2`Knvy7|F*(u3!l-@QUQeEvd^=(@<<mnS`bkr_??^&<1rS4a=eAQJsE%sq3Y
zPiC4A<VhdRGCy{i=|{8IC!)e5bEx>y%g~p%FEihFg|zPq0z5vK>b^FY*!u1~q6vBM
z{+sVH@s6J}4e31d3Tc`7Hzw&}0qruqZ!#YmFRf27|7E=N?L>P2S)%#>jh7Cx_jeP`
zkBygpo<#87N#@<-rBm$vUbFeB@zNeM!Cy6--x)96H-_G~jxqZuNQc>bc#Qd@@zQU{
z68!10=D-B$WA=W3vUza4boaP)f{!acJf6lSNdbE_^)2`i_w-w+^bm|bUp!w(;Pa4x
z{yQD|?{a(|G{2zng#<ot32+N8vER5M+IpUTlgF4p5|yXl+@XiXvGii4FZyL3{%ot`
zDg6WD><RE>y2w(TL=XPdi9P!7+34}BUjE*hu$K_};fLvg`DV`$-G0Y2h9?rOC+HDi
zX^VIvKTZ$DYxGRzN#t9Ql{5;5@rW=++A8Qx;b8Wg*Yt`%W?_#-bPVSr>`_F4&i8&H
zNFk<3`?zPo`h!Xg^^C~VzhFxb)_JU4_eDb@|A1f|w`*9r&Nr|1fA_s57`yFUD~B%-
z=@OCFiFAcX*NOCgk^W4ikBW4!NM8`?n<70W(lHlG?D?`tXNojeqzgp4M5J{hT_MtS
zBE4UvKNIPrBHb&}7exA|NKc7$%tfMok<Jupu1FV%bcsmoM7lzx>qL6LNPi~MM@70<
zq%Vl{O_81w>6ovH_C-2Vq`4wpAX1JcMSc%T&*Rt1F0-Z~3YulL=cH$*+pV;Nl3~xt
z(lKJECV-Qqx5Lq;r0*u_OVXweUSbspbS@VQpXPf4tj6Zq9FeWZ@p_AZcMAUXdH+)Z
zx6;3)k7q4Ur1y~$opl0Vw@Zt_D8aW1e73d*?jZr+d?_bzx1dvy!13=Dbe0MDF9bXz
zg9B)dOV7kaj{jj4ew%<>=5su@cE#%yOl;z(U(jLeP{4mL;8iw`PwO0dP6+sUGkBiX
zA@qCzcr1CEAt*-w5{{>Tj}`C{KemNJ3fBogI!?&|+$2qxw%o%hh-RfL7<{Uv+iRVE
zji95)Jv!XW@L@%T{nz1l0UnG02N?cjNn4>~4yUp3>Gzu{ny<Wd7?0lm!04PSMcb!c
z4E~jfz1M3U1RQ_HGwK-v{36Jwr<ND#>)ZewPb~Z`fD?Xy5y#&uD4NE`#=iz|`dw=M
zch9T>e{CH6KgEF`1Ka{{s*jf-BgOlD`b*(`V)4HS@L0dM{j^Ljewx%H^g*XjfA}7Y
z&Q8Ed4w8do(w+l7sW1?e@tc5b0}gqpF?+racq}@_fD2P6FnQvRgWnnl-W>=2HwFiv
zU*~jb?|`0v#KAuk2cCv_V{*c@QT8<l@L2t-0X)|4m(%b5T?jgxg`6Qq_H2(s=lMAB
z6a+r8+MN>zem%hxQY1ZY6U|CX<KW*G2Of+A{~_Q^AA~)Gd1TLyIQZjXz)3#QzeC>-
z)j0=xwOQD=nS#y@0$=}qzfu9e2k=;O`0qII?Q!5I<G|CQI<e@ljsyQ5!4uGFt6)$h
zKLDKcCwl(=PaHbtl-TX&#DU)s2mVwXxRuFyB#)H474TU0?McAN{zTh{7a4rIv^C0Z
z{8P{=6?QUHH1!or?0)6Ofmg<XuZjcT#^95rA=<FULwl6;90A;7@OK=FJ3)Yx9_qgj
z*(nOXF*!D$wQ=A*ap1oPoa9OWRtG)T@<d92QV~2_K34)BOW$sc1HUZ}{Ks+NZ^eO|
z5WralZ^q<&z)@w?lN|?6|4awTQ~zB}eO*SsWEG3f;W+T|2q~<iT9u@)03M6Zf;jk<
zfD=E-K~7Ak`GA0@33#Vy>oDLnE<HkT+5SGttXQALYWMOuaH*`O)n`xl;<tyZsvF$C
zs$~-WPH}oo3x4|;znGkjv%^N`zx#vX=?!hIRru}U|CmC0jkmFu|5|qB=czM|XSuOh
z<3AZ)l<CB;mOJQo?-$eWmxB}zeOp?+EsQba4_<!`6eEn{SJ5NCd+q!TjW{6lma2wU
z=hbC7Zv2nDJ;Pn*X~e0sz0Kz=%Og;Bqo=LS$%?BO$dQfTl&;0ExX*D93xCnoIb{x4
zL$y7pR6j??OPi-Pf0@Tu>}{`Z^f(q@{aKi-{oib4ShjJxlZ);+n|+_LFAZnWm(Qn#
zNJsvUbR;ty_W~d*cSAFjz~^pnZn(AG<8JY`MJvw#5rcW)&(m7f=5ds=AE{ql?e@`c
zvNwBcJxt9FL&bF=zqP&jnr2T~LzAPnwxO1u#f!?^_MF94&9&a9g`Q^6!*vY@mp!*_
zWK&@Fsy)jZn#*AOYCWxZZNoJSx39@v)97vXw80?Odfm$!z13BX?pjc2b62%@NHyN3
zmPTC2s3jv33xj^!y}@18+FG^B?P>P4u9E8L3WvM4y{U<Q;oXqKFf{l^pn@sbTVl!W
zUa+{Z#Nl=<Dt5b(!_J7?p$MQ-yjXG<->|5##91V{7rL&QU+8jQvtU7)qugCyIN#+!
zjT;x0d9zyDeU6#}_6zX*r`)+I&CF`TjS^3Dv&ZdQ$@}eThAceJCRbBdro+{go0*O8
zto%9jZO2z;PVSuSysTV%4l;IvWM}4Q=jYDJ%qIxpW#(q(=4a;RW@iuzL9;V5Gv{Pw
z%*i2=_B{4w&&<xs%FM}fIP7+&jm_>>43%RAI_YV}T^KhmtyIy)9L_iWm_2@up8Dg<
z<=0!BW$w>rSz#(+P#y3OFp~~PaVE72CzqM;)-_Gc3~+=CG#L7-<{D2mDPzQ_Gi7wc
z2YJde+>6WHQQ|FMQs&F&9;(6H7Rx<3qH3UH_AFkbuA$LW-Ch^7Ru1$M6JtemZ8#iz
zrkfaQsDbh|dYm<mISp-YFRuMWV|!|=d{tbQ_H4mq9d1H-s+wZ9S!|D{K*NxSjxhlg
zL4Z;0lrJ&56I~E!qM><N{D!#49wC_YOgm>Z(i#m{RBMakID~xMn`-kcfG|FzPmtWs
zYuvc))zIv2Z}T7mao2QIxtYOmLpy8g3yLZ#3g<iB_Vg@Kh<RVth&y1MMWMFna-(OY
zCO3JSYMNR`U@_&6#5ez*(4vQk<VIFbaK-L`;p&>((^2DTVbjXUIVpdJ+wH4w^{#Y-
z(`CMTnuXq0L`@@Q?XGR}x^dU7w$a1qOtxOFp_yHngCSei-UO33s_Kn2C+s;~-?$RQ
zQ}PjQ7GIy<>Zwb2yO(uzxLaVcyd+`YD)$PCEMebr>KfbI>PKnCh}qiEjJtb`tr1}I
zC`^Y(v`EIlp09VT(Yp*&DvmfvAL__A#TG1i0SrN7Lv;=Gs0z-O1|>4;S=qP(*osSl
z5eOMMQjL~X5s*Ebx{3LnQ{!9JLi0KgE@@>$EhcsipB!gnII@`~z^I^aS#Brh?lmwC
zO%Om--^<HC*SX6^{cNmE6dTPeo1!4KjioD^3^Oi0|Ll8TG}?rXP=s2~zoj2!tVN%^
zpJqAH?7x;cX-3U*cTN3rcU@IOV`Shl?i3n8f67aW^bmklGuQ3*@(CnDxR_RZF%2}I
zZ35egxF7@ThFo_kErmo&JS5=4G-?^Nq=c&(V`Jp}O1G0;=DcvTQC(FFo7m=yHqK?f
z)|mc}8+!wjh(MSJ5=_o<BZBiq%;CtzSy?tMipuS9-$o^gc#BB2VRHk|6UW?ePUfJu
zZL6AV9Hli)BQ!5URJX`+{CPGF7K>Pi8-+*Zje=7nqg-)6??47R4rL+d&W(+P&@+13
zJj~m_5{QV4FbKI6i#2+peGF58VZY&R_qn}w6vi#{j57YrakhGxsu-rQn80T<m149m
z{Qg-7{}4`fTbnK$?vKtQ<QhG2`n>wIKrIHp@UnJ2Xd<7`TGhIW&8-o0COs>YiN%`_
zjpTu-v(|y7nYVmIl*wi+t<Z`+m^t26&eHhvCC1K;2(}z6%H0Tq`9OSzX+zzFT*(hY
z*<wXSquuss1;~w#9%4ujz55q45V5hRs+G1%GMR&elk*|y899E8)zNzBEH7~nF92b1
zY57-Pg}o8UeO>cP?5emI<C1+7s1+5tv#{>-bQr=naz*7%vWL+<8QD5a<{T`&8)=ml
zcToOwqX_$GY&T-UMlBIW%h|oG$=fV~6`>ZRJH`Fls3u5=`Wkwq2yZMehj2ba7%*}r
zarV}0gt?9M|FbA~22=2cHg8R47UY6(ZP-O;<?)FlEaa#tLrQO3)#R(HMv96ot=Hf1
z2PK~LWzFsBv>Azgm{n4G1XSJL&{#XWp;k(7XvTg-i^LG?tJ><N^x9R;Aj(r;D=%4r
zuo!FQ5g9kiT0M<bR6)G8H2R1lVv2O12Y*PC&f?SbRxeu+rhDqezC?X3>gqWVtwH?D
z77o}MrWwH*#lmMc?G!VLd;^11)Zd9Jv492`yH!mMHK682!}v;P-0+rRmL+V>G*N^u
zwzmJHgzk0W2pV?@_(S)m>Cw{ymK*-k&oy;OI$n(RdqjObwdsf=)z6J}a3Nky_~`9#
z6ZQ2}zgMQ?6Rz=bB6A9NtMvN)qQ0J13S@CS%r9>l2$bO+r+Sh0_4{ag+KYPu^iV==
z>;2cyKW+kyn$+9Z@3-lxexD5}?1|>T22i>?rq|c+i|J{PsHgL<<LPM&%IPkep4acA
z>8VvTNc@xRb^Zle=?($c>+AR7^i;nOr?;=y*ZZ%E`tt=r{eGRE>i6-eK3%<wuKyjt
zh(#f0NwOkCkClDnWN+jXtv`36*jV3c<@kD<A@o6~f@4AU=;?nUXRNQ^Thdc|k*FY&
zf{|J2hsYc2>*w%#Dvl{5wW9g|si?2ZU%y|Wr<Fw9@aTN&pkLvIQ1trxeHuM|T1OOV
zbo+E)$yh(5l_Tou&Zr9d_~~T#MAbhk?*HiN)+qj?$Vo4vzR`Z@_s{gysy8Ik==yH}
zj-zlk2N_C0Al}Z?Xnys)p1ut<9BD`D>-VFQ&$9j}s7qbc)l9z+WD)fr&<6%M^yuyK
z9PYiMGU>ivU%&UXWevx$i2C~c(Ch1Z@FmnYw!i&uUT-^1Y&;n}iG1tz^)xlAzJ8xp
z6ZN+cal@n6)6)y1>g)Fide-tvx}DHT==Jpc*HNEfk^bMqOSXvm(fB|g@mvA`!J_-A
z*PlKDo8uBlr$cGf5V0Ej*Rn*aAm@Mwe~TwwfRE0P-Y;A$itvut$YT}f&lOP@m-Tja
UL|h|?S-<1Q93v;HLR41z|I{nl(*OVf

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2026-01-14/1/main.cpp b/exams/AxelRubini/2026-01-14/1/main.cpp
new file mode 100644
index 0000000..150efd4
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/main.cpp
@@ -0,0 +1,89 @@
+#include "include/Geometry.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct UAV {
+    Point3D pos;
+};
+
+double runOneSim(
+    double T,
+    double H,
+    int N,
+    double L,
+    double V,
+    double A,
+    double D,
+    double R,
+    RandomGenerator &rng
+) {
+    std::vector<UAV> uavs(N);
+    for (int i = 0; i < N; ++i)
+        uavs[i].pos = {
+            rng.uniform(-L, L), rng.uniform(-L, L), rng.uniform(-L, L)
+        };
+
+    long long totalCollisions = 0;
+    double nextCheckTime = 0.0;
+
+    for (int t_idx = 0; (double)t_idx * T <= H + 1e-9; ++t_idx) {
+        double currentTime = (double)t_idx * T;
+
+        // 1. Collision check every R seconds
+        if (currentTime >= nextCheckTime - 1e-9) {
+            for (int i = 0; i < N; ++i) {
+                for (int j = i + 1; j < N; ++j) {
+                    if (uavs[i].pos.distanceTo(uavs[j].pos) <= D)
+                        totalCollisions++;
+                }
+            }
+            nextCheckTime += R;
+        }
+
+        // 2. Move
+        for (int i = 0; i < N; ++i) {
+            double x[3] = {uavs[i].pos.x, uavs[i].pos.y, uavs[i].pos.z};
+            double new_x[3];
+            for (int k = 0; k < 3; ++k) {
+                double prob = std::exp(-A * (x[k] + L) / (2.0 * L));
+                double vk = rng.bernoulli(std::clamp(prob, 0.0, 1.0)) ? V : -V;
+                new_x[k] = x[k] + vk * T;
+            }
+            uavs[i].pos = {new_x[0], new_x[1], new_x[2]};
+        }
+    }
+    return (double)totalCollisions / H;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double T = parser.getDouble("T"), H = parser.getDouble("H"),
+           L = parser.getDouble("L"), V = parser.getDouble("V"),
+           A = parser.getDouble("A"), D = parser.getDouble("D"),
+           R = parser.getDouble("R");
+    int M = parser.getInt("M"), N = parser.getInt("N");
+
+    double totalRate = 0;
+    for (int i = 0; i < M; ++i)
+        totalRate += SELib::runOneSim(T, H, N, L, V, A, D, R, rng);
+
+    std::ofstream outFile("results.txt");
+    outFile << "2026-01-14-Axel-Rubini-2158099" << std::endl;
+    outFile << "C " << totalRate / M << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2026-01-14/1/parameters.txt b/exams/AxelRubini/2026-01-14/1/parameters.txt
new file mode 100644
index 0000000..fc8513b
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/parameters.txt
@@ -0,0 +1,9 @@
+M 1
+N 1
+L 100.1
+A 10.2
+T 1.0
+R 2.0
+D 3.0
+H 1000
+V 3.1
diff --git a/exams/AxelRubini/2026-01-14/1/results.txt b/exams/AxelRubini/2026-01-14/1/results.txt
new file mode 100644
index 0000000..abd2ce9
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/1/results.txt
@@ -0,0 +1,2 @@
+2026-01-14-Axel-Rubini-2158099
+C 29.7631
diff --git a/exams/AxelRubini/2026-01-14/2/Makefile b/exams/AxelRubini/2026-01-14/2/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2026-01-14/2/include/DES.hpp b/exams/AxelRubini/2026-01-14/2/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/2/include/Decision.hpp b/exams/AxelRubini/2026-01-14/2/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/2/include/Dynamics.hpp b/exams/AxelRubini/2026-01-14/2/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/2/include/Geometry.hpp b/exams/AxelRubini/2026-01-14/2/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/2/include/IO.hpp b/exams/AxelRubini/2026-01-14/2/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/2/include/Inventory.hpp b/exams/AxelRubini/2026-01-14/2/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/2/include/Queue.hpp b/exams/AxelRubini/2026-01-14/2/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/2/include/Random.hpp b/exams/AxelRubini/2026-01-14/2/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/2/include/Stat.hpp b/exams/AxelRubini/2026-01-14/2/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/2/main b/exams/AxelRubini/2026-01-14/2/main
new file mode 100755
index 0000000000000000000000000000000000000000..d11762538eaaa89accf31307b60abb2c9f98179f
GIT binary patch
literal 43768
zcmeIbeSB2K^*??$$wGL_T`Wq9SXaCFNvgzb5+G5*EM(!XZZIVQqoSLTY)ER74ao+A
zf(Ca3+%BtVwY7e%r4Ju#Ev@K>kM*gT@QhClKGIS(KH*&>5K$pMvA_43nY+2!WYyZf
z`u+Xkh3wopbLPyMGiS~@^N{R~PWRj-lS$H_WNDT}xu$bDq)-&}|605tDU|Z1G<;g6
zGo=y8r!W{VFXRbI`C~~QoTdsmfvMhBQ68U87I=E9b4V%GOZ41#Ixo>v$-?tg&rGjY
z`oLplpRsg}o9Fe^SdX>WB=F->%P0=lQ)4}njrDq7ZVe4iE2t1ptw{BHNq`Y(%W5h`
z8XlZl2mz0t>hdHW>8C`<Gd?Xu89jyUQ<CEAZ4~w5Q=7ooQ)+`AO6jMsjdDX%D}%<w
z8ymCIcl^~<FP=X=UnuJ7sm^DKUT+ykD2Yp76!r8}=ktfCr;Avid}$)oMOq-*OEi8x
zq5(Z6{i27!+4vz{n>T-<l+-SD5=<{QNhX#TY9l3yyk1VY6YxXBLG@p{sn_G0x^vXg
zUro_m+n2p?=WRb%&#$jrGClA7`s%6mb&aiUQ`_>VPo18Z)#A&_VfCh=E~&{#{5bBD
zl=gOWlH|u&jNM?OvKjcf06*2A|7F{QhpWq)pBQn0d(Si7*WR&p>N$Zeh4)NudZf9-
zeR|p_$M=u5zIXDO)89K8n)u#HR7v=JfexQCOzC;(=y32#ba*)UZxX=YhCqhHFU8;v
z2j2!k4hNr<fd1tP@MZ9S_AvcA1jQVV{`V5}cN+#{IQ+{&dpP(g4B&8ZXM+CTlK}tM
z3HbaX0sQp@@F@xUwLgK}Zc4!C)CBVXFaf@tfS*+f<oR3z{09=~=cokj-kYFb7bl>9
zZUXuLDFOYt3C8`J1pPWI0sQ;~@aGcnb7}%Pyp&*Eq6z5dB%t$9f_{-*wc;oKc`|`K
zKTp8_4-&`|><>%-yae#W3ECZzVBCKT`*W6bnq=L;dtl{>6oecIzEQy21$;gDBzU&&
z_XT_!7$vwx_;ss**9!XC0^Tm*6TuJRmk2r~0=^9LA^0W%*YS^l{@KzvY0Es0NPdK#
zBlscwLcym_XCC+`e96Voq#T||tw@K1*MT2`7Yh7~1-|6*EN$>LdRqLI&3=zZ^0>;1
zJ=NZ3@6x&!zqh%pcuu{q(OXuzq~6QRhA+8teyM+Yy|1dW-dkjME|)x4milwDJsy8;
zvu}l`-rKm;U+eKUH~X4PF0Dc-&}Vo&Rc&o{yM5Y{%9gq+aL`=WxO7QtjjO8EZ?{*~
zRyKS5&6Rcj7FU(Cv=SdqK^m0{c%3>Q3Ws7lr&ZN^E1R7t$?>>+E%f8B^rHt?mMsD>
zPt>kKo8HQXVM%Z%^U;C_*xsTX)~o9JlI0CVrtIsJfg}n%3zncWUazOFvBe8PS2k9A
zn!QUZ>nj_pyh}<zEI)?Q=&Sa!HcPWT3raC0BrSU`=eee?-kU&1)N5ahm+?8j)K}ms
z7OlCeoz4ZNzA{GY(o+AlD*wtRF9e!j?enattM)cJX-vRpo<3rAjms<R>#9AK%}ZMw
zyp8^UWz=SXk(QN>RnC&C1|~Zif`LKD03_-VW6B_zy2h$zFJotTfqi{Z#guf$Qm-G;
z7^DG`!z$f^0pVjxFnuZWlx2IIr87JWjC!2IM~LgOt2ED3I?YpN_c)z+1!rZ8jK~B1
z|0<<-Qr$9RU0wNkONn)uPa3K}AES<`Kw5>FMmmJipHbK1@ik%aX}W^Gn7?!Q{2k2h
zKiwqecBN+ttVpA$s?uLo%bWNnb3R*`6Z>>sIhRycgJ_Fi@Ex0@bNC!ZSH8|{$zy$o
zViP*E5|=?34VZl36?4I^Pkj%<_U6jwm6%O+)TU=?TbrlJ+uY)7#2oRj^eoT*=Dp)A
zGpqD9W;o-F1mWYOu21k`lovBTCI*4+5_&t`Q*vo(uBV=H?aOUy^|Sd;N)j^-5J@q&
z4XoR`jto(vm`V0ctEq2osf{6i9UChuH?Gjlg05x>%sLnIS0LrlFgeMj4$QHbjlp!}
zM81xO@R`6gx!KD+nW!uJ=KC`L5wkD@ZqV22_xNf&&6SNyy)lETJEJcp22K(vDwI7o
zsdT}7J-fgeWWDpk8|kwYavN|()!wf(xTXH)VSO++J_aTHhQ<>j2TKL|+^_d7g#{ak
zBo;QVr~~&4ye;rkn49qPRo8l|YOnRwRMyo?5QX1YO$lNU6xX%*s&aBE*6{nF|1`BJ
z@}StKp|XxJ$Zplt(agTiD>Zl<sv4SD(zFtVXt&Ylp*Y81=WCQuyTxB!b?&*ehM!K^
zhS=NEDiEfeo#0g*K5xz(Pi|JWG|%mtJ;#%im75=X&5OO+2VQdrUURahag6eEkjTr*
z%^8%n+XrO}q&el~j@d4cJu5fMm>GnXGpG_G!X)fNBpLphk*9wt2G|JXN3wjXfR2(z
zOJne!62mjIlCglB@eg|?h&+h~c2TecNtnD9Uc)3xXe~e(i?C+Z*BvG2tQ;eub|YZ)
zm_V;ulvg1C$gMv`#GWQC7qAI+bqI<_Noz#@c2+)83W@wymLDPgRODMH)!{8!`V~Iu
zF`;iWMH%I1_x}tL`&j9Z0#?cLW27fUUcE6B<)fviMSkV}2f%Nt^f!@z;el%rshg!k
zBEO8)Pmw+ld4J|@SkW*N)SRU6Hv-6>3R(!^$q?%W9c~furdxTr4%hRYw{SRw1MUW%
zy$1Mq2EbCc0Y23LKVX2{4e%ZVTwi-oahu?W#`0VPzP_G<FxWnpUZk&&2u^!j`lGLp
z2!5dsM5?dj2u^!q`lGLp2tHE>BGuP-1fOnz>+3jz=NsVqI*#B42Dr45XRxe>jto4h
z1~^7B_E-#XeJw|Y=>|BKWU<F;fK%K0lVO0<Sn5x<0Zu&WPrd=J>jae*8sJd9*rOQW
zP~6y4Vt|j0K_#i&0LMg&JrxFcS`3PPasym8z?%$kiviwdfR8u8+YNBz{@Qv2oc3S!
zXQKgrst!bYrvZMN0lvuqpJ;&JXMm?0;9Csv?;7Bb7~qo(@J<6<9CfhLy#}~`W<mws
z2KX5UItL8!?-}4d2Kbo<xMqM`4e&k#{44{!-vB?`0GGtPCSCi!0iJ4r+YE4v0Y1e5
zPdC8NF~F?`_<tGT83uT!0iJDu|G)sxH^7C7WTk}$c$NWQF~H9^z)KA9Yy-U90M9kR
zD-7^F1N__9Zzb@p1iqEPzgq$y%HR7`3A~@Ggv|SVlB9HW`jevFN?>Q|4%Sq3+EV~W
zr#ypC`OHGRQNEVSB0W(&Q?^r{LYYW6%RfeW3SlChEdLPYDRhZ!Vfp(hPa#WW6U+aa
z@)W8>HnRL(l&26S($4a?QJ&mIq>1H!OnC}PA{8uu6XhusiIlMXb(E)2HB!j(&6KB*
zB$CbYKcYN^A`vUgFQGhzAQ218UrBiiJt7jzFQB|k`M#3?Ou2;e7RvXq{A|jPr+hcd
zUqE>ZEh3#PpF?>Hkt17J{s)w&5F@gQ<<F)(g%**GEI*0z6jDUmS^gBtQz#K>V)@aO
zrw}4i!SYFzr_do%!t$RsB2OVhq>$y0QJzADNH)vAM|lbnB371vlkyZAL@X@-cgj;p
z5Rq8^dCF5L5b67Z`u`N=t(5O!`R$Y^*B|L-`Nt?vE<e)A@()p-TzzB<%im9Va`BN(
zEdOiDlWUJ`Wcj-&PcA*u&hocWo?LmPiRFJx`3%Zeu>4JwCzl>6VfpJQPp&*t$nwpU
zrzJ!ro8^B*d2;CyEAm<|I=N8^&-~0SN!s_2Q9?zw)N1A2lqu9mYX-_1i&1t8Iv-ay
z9%T!t>|vs`43)Kdd;~6(T9b>^TqRV-C{5s$QWbTNb`hv(^H`fh+ZjW&?jOnnwR4pC
zn@{bGqIOcgqMa8B>2;thp`fiF9U17+rJ&{{YJH!hSlyv?9B!>pLVjDV5?W;|(dt+&
zWZmk!+TvkJI284D-rrTjmXAdf%czMkn$XID<5rI->QN>0h&CFz-i_KEB*h(Xx8Bja
zNeMk+YX^%;!BM}R_@&rU2{)Ov*HFFpd&ctdgUYv255lW#71~y46tQ2Z{T*|kkWw*+
z20EQV96!mJ9cXOlAY#j?u?MyLiKc<0Uk*ZY6Ve7lxg5NnDTaaT4B$k(3>s@o4wl8E
znFwuGJlfQFw7-7_w2AR(BjVBim(cn!>M`EJf~A5za_|*aVBj%G=v@R=Usu##t&Es?
z5c!%c`OF~XFG*kiCZE|(NRG?x`yM0f?^xtm=qOuQs;qfGok>2#Cy=7@p|E$-K;<jp
zt+w^>4$7XOt)09Co*G4NjM7JEja<K{W@C+^<*#~G)V)ezcdF8*eNVCPRq8su>d5-=
z*d!&e-K41V`;|4HHldl;SCsJGwsth8sL*jGJngqGIJC?nTOkBcBOmP~hHySA5%!)U
z8(YgOcqvC6a9d<+q8F-Bq3waYa)+yJ*^2raO_CKbZv$fA%=Fix?k0U6tgmUGMx&0u
zkhq+|<E@1xkqYe-7*DRcXTq%wQC+#C4&GB)vy;SHq-s}P?O5!%+HsA;vjg3DUqKmE
zI}a==q1$ciiQCXtTRT$f7O{6Hys6G!jZ3~^&rrr%KcR^<ZIhsO2>v+{wMz`tj>+ST
zY^g)Zox{nM3UWXD5^|q0#`!#9<SawUz0%LP8zIOkUqWtkJh}9t<koX?kIq9UA-YdU
zya_~ibv!xiP;v#FT)iN7|Cf+Uizk;cl-zqKSZB`^<gOZqoP8e+>kkdY9O|y2ls0in
zugvBB9G{TV$U&5L4yCjRl$;%h<(pq5_1cqSLn1lt$CdDAHj4*l=`q<-Z_B`Ewau!i
zM~c*U@xIuWj?Xfi1=`oR2d{2hs&))9*)h31#pVd?HeuvbY|es@Tc3Q4LMy1^_XXEu
z(DY*zjsUjD$$K)9I!5*!GwCrhA}EWBvd@l3qi7+;2JPPmq+<^G2hSdpuj$fmWwrKb
zDr%v?X+Nx815ji+OrPGT-gfPN5P(;V)Q}D%y+NcqMA{?LevwYZoF=^KB3&p_zepD|
zyj_u>AYZeQ;%)n3m%9HNMSW8Vyxmt)=CpU(_rYO42!!aVxz&>N(SSSw|C^UOXnvlO
zf`0$02-Qym5{2rcqCLV6?+_{Qf6wrz{hE@@lZx7>bRD@^>FQ5bOuLo+C;byZ;GHT?
zAT`=kBcE9$NqT+auYIN$b*0wag-T%NUBHC6-tmu9LNjLp9zAtEKw1@;-EF=I0Mpew
z2KWV?LdjsjiC$zWa0gHZ-sCf-Qbqj?>ko?(8mWW|HJGW9ebit_R1Q{PB-(Gxm;B$A
zx2>2%1AfDYkab|E1(DQMksp3Uf?owyn)or^;QUj!QQWVDPkkBjFQ=HT6m<J{GI+FG
z-qzRq2pTo;=UC_t`z*|HVHM<7&sRE*%fa`Fp!$WPo^YujX?Ieqh?4^S@{05DY4T5o
z@LQ)TAtxkrb?WYvbct3>+%oTQ$PcI3);le|uPfm;lQx>Mc{O-;N-j)O_3v)=kXt>f
z?FZT3$2Z3DbGc)YJG>%QI8(MV^H~t0$-)1lzJ*p>mC)50F7*{~R;+&9JBg2<OFgWF
z8VJ!pFNRd`I$Cqdb6-(9p7)PMv)Zf2qEWCu(Vh93vIZeQ^u`-^;RTf2SB+2)babwK
z7-Z5ZBz&~E;E2D-MU4%jV{wIAtz>_0<+RdWnXkLnfD~w1@WN<~EmHeCI@`={RqIW5
zLj_~vVUBA+1ssbO!t>v-i|fITRMLfNB^EotyVyImcPUOOIN)EXglY>l^#dA?Lq#FD
z-yH}m)T3&$<_9y%h3DDiU^(O+N)Gg&EeGv*#Vq-5T-bgpsSpP1njHwzd*7tUV^{A%
z?Lm;(2!7&NIgdr}idt_=RiD)s3s&kGD<}IHE02-d4dy3EI>Y$MCVs{QJ^??Y@cJ0Z
zM=@<zy56(O9VdX+v5z<$v{X1{FozK0YuYJbuV$kI`VrHOd{Tcan=40|aW6tHRG6-)
z<dr)*<zS-#V|~xT&=7zR!)TIFFzq-PBMxxA0H-UVazGBs!4TQX(6yuxa<Ch$yF=b|
zgza+hbd(fh(SRH#3|${A4mBck*uTgXTAf}D1*i46D|BO_D|}f=F)3%kU;X1;p?L_u
z5ZfnV7*T3PDJCf|$z~-Qq`Iww8dIa%L1aL+^?q0A22ffAN{yiO3Q?NNDLn!dl!DSC
zP~s(=(mex|PH4AsN^&rRm{pHNE(L!|==wq>Jf{Sm1l2uc<&Yu%mH-{4R+NG&FX2=b
zohq563keOqu0|9c*-rs9v!|GYpzADwymY!wPIok;i)kEo>U8l!E%qH1{f0_wZz013
zeI>YbtM5c^BFziAZ5W)DAngFlS1{72C?RA(fQCIoyB`%voq%^88kx-+0S;bbIBOZs
zDqA`ev$le=9S8kBMTM)5e1c_?z6fy9n#vU}vO(_k&=&|I%>~WjeVK)dgaOePAsW^T
zd3Vl2p%}(@wF$^z80Fww=ti;nKHD6i?mz{<q&w-_!6Upoz)R4bbnVX!XO+#uyK^69
z(VfxM9ZTdpY}JSP1qu+{YzXd3U2w<<p;)wKj0!>%a0J0Qbiv^zhEptBO64uhGPaZ&
zxs4(T^a+#jOZt?mjbv2H2rogOQnj}Z6D^3AxAY=q^*&i6<Ef><&V0jSfa{%Op;EP5
zsd~y$ret=x)Xx_x>aIs1@~BIFwiLz{;qYEL@GvIVBLKpxcFDm<FdrVHoc%c2^+yS=
z?r>oZ-Hv@LrRy!LGSdgsu-rn$lcwXcs9qK>F}Xr1J6-DS99Jc~Hb#A3v3D!<{^rOv
zZ?-Qw?-#MWyyi_w+I>{dzjq3~nRdvxb;=KSx(Z&EZ)&FIVU0TK=q0c-JzR8#BwTCF
z#(|byCiSnJFL_-Jdf*C8-bn-HQnC6WzSRR*6^>Cm75fhM-ZOFvXGLV?DV!6Y)xgOP
zMSkFK1y9R?n;{={ul@NG2Tq)Ds4o?~&|KELn$7EfS1UyYy)EY|aExnCGSU7HqE*zf
zHtlho`ouaJ8f)tfb9(|oC|$i)gD`}hS;sod21s7l0meCt7#Mv}sOmQmhM}nee+@QO
zw{0wA)dE(bp<@-Wsk0nug|Z=}(LThfRt!i(DfIJlrRuLS7q;g8RE(UW`fU|h0c@~s
z0{eLRt&Lm_UN+kv!HXdt;Cor*^f%b<M3M5yLjIUZuWynuOKRkdeiu}uW1k$n7>fxd
zJlO?Oi!s}}-b%(BSpwShSZu3BF2$zRzK2zLAc{qZ<sutfsHEZ(6<q30Id~P(fG$Jj
zsYSL|fVF*~=cKa#h+;x?-IL-r^~mFC&mmhLKO3*J`w(`vzVA4`$K=QM6|c#vgi{J#
zdx~~~Cbmq_`cAOB9Y4qL^AyZ{jeNQJPFxsp!`fE3O>cq2RkWT0*V)J9tNV`0p1rQn
z9W>?uF1F<#lNUdSw>&UD9=0p;J$QWL@t7k20ECZXF;tEv7uM-kp=<KG(^F_{%07l{
z=0i=we7d}hb;20+xMDx1sCYj#a?K$=UqoJBbBIqEo<D*Kb4*_U3uAl7<SWeg=M!s|
zaSySy9PJYHZVo+l6-&48O{$U0_SeV@_W~8cN{zheDWG++1tING>{ix%LK8z?cO@DC
zv(JLrWnlLIIJ5heuE-d5pJIPXQStu9$Te?pW<_3J^9E;@=ObYDDS7?#p!ik7na|t%
zw+N@m*dB=?jNiQ?;oO0g7Q-jeVIiUGc+sg>vh*t?Bv0s<GvV-JQVOD_FOkxIMSaR>
zjpL=n%gGu;N==xPUnM2FYUB#JNlJ?_Doi02^*LRIo>SBhjHB`aD?1cZAzn_S@`1em
zO);%VWuXCAn3uxEU_Ma)0=uwvpo{2oz)5-{J@tI#<?*YvW3oY9q)MnvgrHbVp`iZG
zex;yS4t9{aS@S8^EQ$k_a5Fqu*-KcO{VSTKs^pN>{ed@4Bspb&L>aYT^ryTt;%BAL
z1>O*)N0d>|QR!~5*BKeb9B!hz*Hhf5z8s^Bx-SpZ{T&523ETZHD@{~)KDeTVsFFov
z$*ceiVF;GTU`!;D{a7dx%*tSFs3SYU6~V?D@ZLvj1nZwVK(AK7-exdP?;f;^VT4^{
zS|(ej-V9Fy$X44Xr~+PK>@b9X#T&D5@B@2U!4)tU<sV}>x7s=ZsFBbAK)z`+R$th>
z-3$Odj_^Ee=ZO7UC0taPOk2BKcp;*ho@CmRK7c&P0}Tc=$jE~lLZkafLMZ}IFk3Il
z!B3&*6o%EJQFsJ=!hPWLBAaG^o4XAPyGuZ8u<wwAzsI4Z5)yt2BubcOV2%Xdz^+U`
zd5`b}J7#5yV)``EuD3iM+;qaN6vC|(!mVr<ZsqKlTS35CqWczfyo>o3xR$PCMVKoW
z!VhDo&VG>l-(&M+%Y;1aebKJdVahGeOQobb&tiX`YM9@^Jv<->nZz&*Zyn!mYK4Wq
zd`gs+WPEshdlCaoJHi3I$G4|2z|>a(z{GnOdkyIAK6@uJC-8F=+i>M?(#MDN@qRBF
zXr~5hisXz>(a27EIUeXVfrau<F(xAja2UD8%TwvI(SnNC>^bI?uOWh+^l}s*R~#pT
zyXoyPz3qaA>~&xz0^6}Wz2HFWFF+Le*1j5toY4uC#a$TbE_vO9nEsUA3s*EQk9txh
zpTAFD_b7%Orw4&gQ{|2?pysYj&Hns0VwM!4!iAkQt_+U4&Oh9L|NRD?2xulmuC8u*
zexKHi#Xc<tO0YU4xsH3#4hnY~6h%QWz*O7{HQgnBDErVtp=CD4&VGqnWViS;29C{M
zc!NzErh}LtBooWHYe13_4D2wu&|OEt>vG3;$zX&Q+e#>;#J)CH^#Se0p#@jq5|HHQ
zeptu0#M38*4)AG3R%_oe`3D==BtwII`e7LU%BEo8A<SqtmtoWRT*HoQkj-YSVf_<X
zD_{rhBHl{nO{LgKh5I4b*fE{lVWR1`W+#P(#<flCPzn?_+xk!klBtm=9KwmBocUW@
z4~<UX<V5+F@1y3E>By=RY!p~3sIk}vIb-4?SVA<F4bhFSMo@(W>qAPg6hjfhCv9;L
z^~4wC6mbklZD9mM6DTqS2FabFTR@3sr`kp&V5nF^bO|A!VB@x(&&CJs`?2Z-Gjs+D
zb5X9PpdH$QDd&V4hpZaeMdA<}=)|FA+;v1_paI@C7;%Sb>t<K6x{GE?SHuNNTeGpa
zV3!;uQ%J&rc8{;MxB{K&c&X4L=Kw{_J2%!vnHn}TC*J76nOsT_sxYxBnR}Gb2$w3U
z{qB%^M1QgBmimjs3id`jU4b|H-I;rp%-yE`Ku>?5Kec%hQm6g-B6Ytbuszisnw(aw
zP9Ehb*xvlU%hVsKWPyK7oIyTxVJA3uTHuwX$i?LR9-(<e59xa*PKr+`UD0H$#`=u`
zKF%?3C6(=n(u$QW8wwTKxkrV#-H>XwV(N#aFt%;VlLPAl23u?^SLAtnsJM*j#NFbQ
z8B-82Y@Cp1fD+Iqhq^~mQz)S3=V^F(!q$!!@#1HiQVmVXc@5qUBbZGC3;n{mhXtP~
zs*z8twprZ;yRZwx^Z?Z5@qARNaW<Ic)K)grnQ=dZb0jDj2L-(?i{840^C|~NpxcZ&
zsJ^hzFd8G2(0pd>l)#>JdHg(0Q7`Lv7wm3*OL<brb+i&Vl1_r{Izm!Cp*#tx({rYB
z)=4GoU!Lp^r}UAcu#LW3&{tu3Al5cigov^DXOSxA4DrsTh|M7qUp4C|N=S22M4Ahk
zrfO%r%GJCLq9Ez8y3ljXO6WP&MW^{(x$Qh%&zbsz2uasUD4^sHormeX%VpXXslYjj
zOYMvlgMTNT6ZAkVw0@I=eRy+)u_@_95J0CxOspH&a?%Y`NKpV0e1bu0obrTyl)Xj+
zJ2idux~SiQ4SpUdItrrl&8tA=QKAIwj2-Y)A35a9_L47okLq_~o*l=}VHIxV=)V0L
ze0m|R>zP|Wwy{RG6k0JsEg3XR-yvU4FMaqprKtxL79S$QA0xlJ4|X<VcaeNrtp@sw
zck=?2YJ_(LA6L9x1J_3{hk;SPi$1V|{9z|vws&Do_1RvE5Pl2`1}E2Y0IK-nUfN&Z
z>oRRW-evM%qVC1Q)zq)tNzTU=PT7f0FHVQQtw^P}5)9H6Z<8}UNFUFWM}3Pv-XtG=
zj9P+|>~{tJ9u4d<IpFWe%aWiv{ugcsda;To2*$QaL`~&Sur<6Jn-NU<q#mijn@sZy
zXxe*!XO3+$hL^`ttQ-`qk!?5tQu`y9VW2_NO|e?}21X8bk&V#V8eUoCHKa)t7$Y`n
z>jvJ|MR9EbjchRw(DoEsFxpsGNRh|UKKdOY*M{`3PW#*7V_FYx8$nEaDax!RT(q=R
zM5yIQklCz9rx7`@1V>3RXBZjH7#6NE@(xapiMC>B^L=cTYUhB@Naa5;cW|)yGSb+5
zSNjZyZP;hw=K(JDB^+Vl#0qB@AJQ(LJG8>WHs=2U_KLALUL2~)=uM~nvqkARZNz!d
z58c>&bcdGUEa~Oqf_L2Nn>Z<YiArR*iU9R>ZOZ|6Sacc=aom|b%1jKyjW=#nW`bn<
zsuY|RJp^hNHaSqO^?_owFSxID*<fO`*c}P13&<Q?1Bx`OQ*kOY#r}Lpr(1SycgxB#
z+ULVD(N%7B`@r=EI!Y|geBZSO(FIy|<ApVSVUgO?3;m{ZOFAoahn(rf1-t#<cdI9~
zr_lr$afjN_xe9b{cjQ`B*X<=j;ojRIH-x{vKSs(9dqOuV*yS(Rclpa{8&O*VLO6B}
z&4$elU!Sk2$yY^A0yeN0M*JnNe>Sgw=|Fw$Ndl>_ZzH9-Dq=zo=S?p4BtOt`hkWSD
ze?ffyir9F&un&}q9X*>;@TxzfW}_0i5UjH8YdWg1FjoKk3g`xQ;BLaJt*<d;>=e&*
z!7ss=z3!s@zs%RPTY&}Qt(%KO=TKC3t}C?M0*SwSwL9|=zf%%v01n^hL?s~09oIv6
zz0c~g*bb%Og#S`#+Q<Bq?ETcZ^WI_kn`q<@LyePC{k++r%>#n{x^FT47Z;D{k1o)W
z7^Je<)?_B_*lKISW*5RPY$8q;CwX_<+8E-8Zp4R(L~w@z1EQ^YiO)t_8R2Gw`K&^+
z0zq3jA&15ta}b>%ql**tgUHqtAzy-GLZdsYteo1Tqin1?6~O4hc4Z3VBQ)+eL<U7|
zKx0KAhvvpEBJKume3@xnS0OQuD1b4J29e?<46Xy0*m(PHbh1tB2E%Ns9@Q37)llwZ
zsUS(GW*sP^*q=9g9a=cSPWa5QZT92Zy{x66O=C?U+6l6YL)tYjMx*P4wx5AY5a)pl
zXayU_y(sv<-8^Ak>_j=$>7x`eJZlAgqFA0D*8R}kDHRw3c8vIA@CAupjK3B^r>&Zt
zS#Qg3zdj!e>=26NZKZR_U8ExtWkj_ptUnedv_K0LS*(E`GuaQh;}=8-t8><p96XiL
zML)nGUGSovD;6LvMm&cah1%v9m`oSWqJA@53%(h8$ecm!;Iv>b7JL}svyinPmotO5
zZU89lp#tDDvSLU(0b_lnA*JR*<{l7dLy9abN-jqX_PW*yX`<IA6mt*aLx99KBXmTa
zwisI8ji8OfTh<M}aV%%vZEFXJSlTGkO-Qx#*(me%kP^C^Nd*noq9epM)uG`#KxxNe
z5=e!7`*w^7mF@);W7dg;9{G+=>-P1C%;b(=;<m67_)M19-7}88As(`kq;VqLF^7&;
zV8SaD^=?}?D%<zjpI1m-@y>2S;P#n;HtI>*y)+6K;6fT;LezdMAh=!|v{?b65(}l^
zDIF<2#O5ZEQW<oRP$g|H8`Yq#kOL_JauI?K)W}ATX(gqgmQSUG!0wkoD``~O;WloG
za3%aHwvd<-f*D>Nn^OvQ`9agF-N|^}%m_h_{_nU$zh!8S_KR#*Ik*WonMfoSg0ntg
zET|7~LKb(pDYclQ)Fr3TuGo$6#6B$RKkof5_h0H4#i1MFtD}A;R$9>OR^L<Pxi7@-
zZA{tETruuiyy{wmRUF;hzzcfSzG@^c1;QEsAL!uxJ=*$+tKf(nOh%X7p@t0iAYzzN
z{PM<&-HhNQ91OX!4&=Ul0{89mhTWL>*vMGFjTr!Ep;7=j_!qiEt%dIJY8+~FVH6jf
zl!HmQ`;IFqC1^;#X*D`YcL2_!JBTDnSKte1&-}4umQJ8o+CenT=%@|KoZTr|Ohf7S
z18DyCu?Yuzw3yClifoGZ{$JS~y5j;U+Ve2W7+;1QGXLm8F|80;@*9EUJOI%oDS=s|
zv_e==Mpn$<Lcr)Dlg!~}E2@#A^y^bw%wGvY$8>U_Z83kV`TWfWyPO7WAh9gwFYg94
zj=DpO$e`^$;L!#Jel?h}WD%(qspjJiJVNb5q-0LPMj?vmq3TqPW=J`u`V5C)YN=2m
zAg)G?ViWVWiO8{8n~$N#8{}R?Z!~LPlJNo+MZLRi^tbl(SxXJ*vzF+I_SvlMBiUot
zA~?eJY7}Zm*l0ko7+I%1YCnjGm^j%Y*ewB^Bw3D>9!yw5HC!bodZ|Q@P_-La3(U+P
zhnY9a9c6GCxNjr}KSX;Z6e5NA3v-LtQB(v#3$g6@g6tC^;Z{M%gLuKcs}buF5vkYW
z7SRrC@9kJGB3^>#y2G__^R+nGr%9^T=F@Fh#_NSoFy8q!U1F8RQ%j#?1Fz&03r}!4
zqnAU5`a<jr^QvroC~7>9s-g~!J9MWQByg&y52f}OR&4$gqfC+wjid82Dvv3tu9#u-
zFL4w!NHKv%I;I_Z29v1ZEx!%@Ta9*{dO(O5;^N+C!9`#f3kYAOST7B60wO&GdfJbv
z3>?zzRM3Ma-UG6stnQCQxrLQKVcUeBa1^VKGLKNg<_uyFl*rms51J@7x-w9&;8hRk
zRmTeIcXIhmB@(FGj&f}iD>L89$da=Njid9j7-^cpy4MYxZ^GdZ38xKJ=^-?7pxVBt
zse>Xa(QUqnL^{@;;Dr<c8nzt^VZ^i^NR|BdUP?pBN_gDOxO2rWcfogL(+P8MA?ov6
zhU)8dp|CqL2ath)mE^&~B4}18xZ>TH^zM%%(qZ#!#5-m}8|xccDIqorT2Vei7YmBC
zN1q~gp5PJMWG?!Trx6~O*22QI6JiD9+w5TS8#kLJ@XO#L){HJfs)l%ssL;Sst0YQ*
z>Cx7*CIJ{MrAZbTv4?qlh)r4wxAlbqZlg1QCO_<y5JA#-M_wXXtFI{7JhE!ZG%9K`
z-AuAF+juQz;&JU6v=nh+fv4YJ-3I4I4{i;9;?8`7?)P`~<8;4I4i><<Ac|%8=M~&S
zuwwI1Q%t**M|c(N7#8fpE}y1!y<?_3RJX8h0MQL~AVY%HAUP&B^-Wza++I<_D`7DT
zT)5jQuR9;MyqK<@)Zm4zi32=3QZdsIr$R1nwa2X<>pj<Se^gOND<K6WE`b$mgW>5!
z@2*3-9h2{XzXIorn38Qk$WcPLDgR09vxMgk&%^FXf2tg)0$Yybohfq1Z3rWrSQtMp
zKU`3_eind9{y#X?&e`&x-KLW@vsL$qlT^3&F06aN2a~rFzS0^u!GFIG>%8zqS;gu{
zkudhkI37+Sz@Y=C&sE668e9ls8vP~)od?FR8ulUFneX8G1gQz+I1dy_Pac5`XlC&g
za;0Ft6C;4%+vrr(I_&70n6Pd_v&HHm7~tNs_&S}W>BLs_ZmU~ufOvLcfAm8+cr_u0
z8sQOE<6h}>MO`fwhl_ER@rAr%0tFI#-0D->@AhI1%Js{Qn;lrSmAf(iCEA}*fL&^w
zvEXtov<kG*Nml%nwv1}w_Dnmt2HORSI;#jMA$LJPYR~Fd!q=rMfp`0HN!o!0Smp-~
z>}9h-xyg>bEXvuBJJb&XyHn?fCXAY|PLPWVb~hi6d<Uiaegf0)tzwI-2%F5r7uWdl
zXrCPb(T)cSu&++K5B+2EQ%%q<wy6qy$WrUtL!H4k6jicDZbF!c^*-!TJ|jf-=;Yye
zdvwXi@%AVmkO6!2WCc2}tp#bidmM%pL-bJMQk`&$*Taial)r_hKdcc>s&M6V33T7B
zeoD86&quXl+&FgOBBM*CTgOh^UU4cUP{(d(iR3Q$SPrVFj%$t?EVL|m3mZvnghc#`
zTevV2w0?ydsMQwlCZXUB(<~^{G+SSQa%vu9dQ!Ux<+z|c2~$nUJP;q3(qG4<xO5Rx
zH@r)UA6nzgChFw&9zf-7)L}Y>{xvd@iy;g#Pwr+Rj62)_PI#nAS|+cfzf{Vj)J{xA
zx}(@}C562RjMdF7Cfr?=5e0{0X#f*)Ayyi4a1I?+;e3}n?%NrvQt&r9*vksGvegOA
zknMC^iQKJxT95~V*e=LNo-N6<2pf}&k-=(|MPx)7js)^iC>XluLy{V=%zC<O7dp3|
zpcqB%cgPV5?uZe0-p$v1>fiAz7+M{bqB506=E9@VmQ84dHSk=D_6riyv7-ikCVH0(
zdMv=CIQDKHfO2}@74)byvY83E5Z02}eTsu3KVh&SX$f;Hr0(=YI&qOe%tv-f-lawz
z>z&z=yP@j(Jf-!B*lUz;c?Sjhn&cE1qmItVGYprkvt#{;K?{k<Ly!mP7THYjKqSV<
z49rw+f0*Ux7oM|SnON9C9$?9M@^nn;`jk#bx{YT}+vQ*uX+y{Jk3f79JkEB-)U7-=
zaJ<wFkF#CDZaTkOz@mN)sM`3Qd{nxTAp^^Hd0wTK4-ln+Jzr*PuNAiT;0|7^hj1`z
zJl(+RBr>;m0#}&ZvxOXu_SQLIZ&wp$XzpNptH9pkR~sh7^)Y)(d$lE64j5tPsP|Fk
zZ(w%~c8=TMEP(^-=4AGl*<xYg+&JRv-9kaQ(O;rVtoxWaYyenTzL}lJC<U;4_+3Tn
z`D3w@D>C?dnMqUv5o~0Bf}3A7Oiw9~3Ac|!to?HEkIaf~<&@N8^s6s{Bk1`_tGxDB
zDhqVshV*mn+C|=S+;79Ri<9_$9G_yr2M*9Wv*`jK-V6KW@e8`;@t5@Qn|yt(f1|UL
z9L5LV=#SmEpz9>z2_uwb>>7b@)K0>tl|@lY;0zICrMSpMP>~WouZu;?^d8uSleVaT
z3_I^UsU7d4DJpn}gh+p=%NDv{s4j!iuFF?cM`2_RRGir}+T`1UT4c%LT40^CBXi+Q
z*%C(yv}H*CGIyxZ>I&83cg%W~f&GL@F4`KW<p8a(pXubI3{%v4x{~>-B6b%h;ss2!
z%Nu@=i3Fp#{#Qt8|CzQ|>33L8YVGfms_t^B-4rwhuchXJc?amycKn!jEN~<__*+!O
zNl7ZrAJoP{@(0-FN6+2rVeOeGV>}mTm?F0@Q&fcB53&PC=y#}Q5<jcb(3JWb@_b(N
z{$5y{?q5og%CoFHwC&%CK!jY8*hQIy$ccJQ?yp>X8Lcv}j9yQ6W&T4PG03-^0hQ8^
z8OGq4ff}RhS*}1^I=V6iuX<Npsur1wys$6iOV*meK77d;@;X}3Jb5NK)<%ORSf9tg
zhfHK6z#<;Q+9+}*L?-$H=6jwbdFq}3!OUi6#ppm2vBG=WCMt(^kXwj&AOg%w8jsq@
zk{BKC?|%wR;qS546m$8J)c#m|2={xy5j~OH2kf#gPt3!k;FV<h2|{vrNZ~Sl8u3`n
zv)@4&p(e-``_OLMTp*QN$?)+;ks0&z4b*G3i;Q_-HOcWw7Gvy+JWC+aBZSLx@IJ6Z
zA|P-1p?m}1lNsVRh5x1<BQo>QmB>@*8TmEEbdcR5e+q<L;nk2^ueKfx;VLh7t8ghO
zgx|@)^#TeP+5v~zbgTGHTueS{6Ti+?!a{)gh_oW*_y`ps1XpLx4!KRAQwaV!h2W71
z9}(li=i|uCsRTa7ev2O@)NZ;t6j+Z}T#J%BKE(?#zArz#fpHsnGiiOA+_95d(_7Uk
zVJnN`g54>np-c>PAFZO;6@Dn&jpXl1Qh{@jQ!vczxslEZC*ak7II<FpDK>ld^5{vv
zMIi{EJ*lM7`IP4aF&(YB)m@Pb0YVDtV6EiEP-CTyi86Q&oi0Lac9^GVw>~joI?i-w
zz9oL4Oul6z(dWNZCT~bWMm^A_oe6rWk<X!N2x%i3H1N0shmJGb2rae_1g!>t0fR~^
zM&=p8`gYuJm<`sNahtOr_Zwi+BX>ggX;Dg=upW0I#6Sv>M(#U_mLN;6D6cE(2(=rg
zHMt)__Xw;3=BFw+t;fX{g)X-2F?I8cE%HqsRHP-q^SFCSH(OF>xYZOpF18$v6rqTw
z|EoylKbIw+tWnEoZ5G$`R1|{^YFRxkRF?cXu%JG1SR;YO`~oS&FgqrHf1H<-lgFC<
zvniydLB3<sh#|lMgy$U6rEwLMps0zd*1%>7&U+DnwlOH%gE!9=L^Qy(pFhSM=%WUP
z-?mu9c)$UT=4Qz8I|IS{h)@$@VaYd}<UMHX07Dg?S%J++ZIx)OhZ;k0y7?_?T#pIz
z;S^g}!!MAOxD(`8HMAE+y%Orh@Vj;oG88x%Z6w}`)pxKX?RVgp(O?L~1{oF$e1oh5
z7_PuBYcGyMc0_)`#&cJs3Nwf)Tjoiv3K$XkU6i=h^`)$p#M@`*igJr!bQ3xnw|$n%
zP}m7WuXfd=XlFIk0XozB2P-qLrU43#y8($EGBs>w(FPa`6`x?+HKaN1XabtC?E55A
zzMG@%#Gc5IVURn@sUa*W{}0XdLi2aAKZ=6@Li-IWY^wkzT07N%sbOkQLTzmlaj5Q~
z+B+hDU<O=lkwSUnw?ofhgksyFvlxpk2Buk|{fQNue@WobxJ{x1d_l$am)_~uJ-8<z
zZ>PjIp2OxF&gNZao1**w3`v?<2X|>(Nvvf&6WJl$%pjeVJ1!+~c;;R#z_hnfnL2bC
zsQ`314a!M=LfxfZ!9>Y7j3Ylro!++ylUY?@GAT0631cW|)Zude=XEr{gzRAaRFFGf
zByf1<kFoC5{>Yl$6?tlS4u20+%|-2_LADq|`oi$It2x<RBD)A=5p(p;pn6s+zzBCe
z3}SbKSmaN=1i^N|6U;biCtd^4&xExjaz7)_Z|%?w9W8DuT9pt@Pd|R$2j&<v#DPW-
zT|~T~k02%p-9hK~bm5acEBUIQS=i#XpB63=ev1lkhba3u>=_-#4{kKo9~?0Ku=lAH
zf+KM6q_})zIgXBM<b$~7bnw|4xfi#r=xWo!r*XZh+k|CRx47%nmyEkkC~4^%rN5Z<
z7rGe5ihx5ezCPd`PeJi+ssKEK9!1Dsf*aP|a>sJgg3vm~eduTD=mgXW9on;-I!Eju
z*@ls3huLqed6Si4s`8@Oj6G9Eb>o+Z0zD?>!~tdhdrI!l+Hin6<@GJ8Kd0Y(3$v`E
z@}|P;sHs6$!H3A>KtD<QKPivxF?kT{N@$|8hyBhO`YRdxKD4V97`s?k)pb;T2P(z>
z=2$@gD`Q0J+vi&ed@F(fv;^pHX47N*&WQ`GRlY|2Y4g@9`s?J@nr2^vwXwCn-dfjU
zZS?uA>?=J4qg9oS1j3(p$M>RG@mI_*xL~=r%I|Bo*5f-ryv<gBZDpgip|Z`>f<J_w
zktwQ4IoUbWr)Jxy+ViG5+Pw8s7ql*^Ypk1^W1p6vT~L5OwC<z7w(hHwnkt(s8@%`m
znU*Ynn_nuE6v-_ul8U4SQn55&YQ`UIulMt^IaZ0ceZd9z(gAQ(kH4_)scgd6F;wgA
z!c^lqda<;3{?dl7Kg{9qK8Hwg5>HRx#do}Xjy5K1{H*csO<nWzpDm-+lksWSGn`)Z
zMm=vjJ^4cVBRTX3`MUoUjnb~imItHJTBHvneFEurq-_xU4<3p}yOG|Cl+L~L{x=$Z
z25H|`lq0nw(xRX|8*z0J(LqW9M&T3D=mDhJe~Cs5QNI)Eok%O-buUVW7up_;ZbFP`
z#YQduWVlp;%T%<uZ9+=%)RtFp%L{mYNNIB>`#?0>iL?jlSk!C!TQr)FRQe<u-9Rax
z2|STZ*Da7tZ5Gq%V@IZL1WkfZ#!m(uB$gleGZ-T+l-TftU+R)N{}_$-piL>wGB+*#
z5_!yu)OP9ONf-Vg*LF6b5+N_fPsU3)@*@BqD}I{r^EPNUBb6L!mO#?HG;8DNG)qxh
zsuKrg)b8#0Dcll`qKlw!4Nx=r_}Pq~49IQ`QfYRYC7gt&HzYgKtZP#oX&C`?QCjv5
zqth|~aHORJVRl-o12oftPK%CX4?qr7H!VA0UYoKZIh+K2!*~0kzZIZ+h{{mymZaHf
z={G0OO|ynmW~XIrFgwz+*N$+c<p)L<r4=UaOUnlU4bD!p0+F{vvZBXyU5T4Xa^!!1
ze1;^QuFI2TMzYh;4qd}f`3<Cksy8Qr)wR@CAm!4u>?H4K#ylj$nJ2m=$JyY0Db@3#
z9{5jLn|w3Lh3Kxrj}<y}50%s3l^UQ6QE<AehM~I^_zQHp|23Gdg0jhIpzVcdbSC6u
zkPEsUPI1QMQbcl@msXOrb#z)jMxbc0U@)jei~e%xWbinN^lm`LjMfktHzk`=h7&TX
z(pYW<E$fR>`mHsgL-lE?qKxKU5z25?PL!==WyHh#D62);7Aj*ha;Bw+lflCV(x0_7
z&Vdn0%b`L=X;zd02cvMwm=dN_v9ZoTb-D`l3~2q3Xw6NttW7FPOAjPNnOoD+F?x=)
zRAmRE$`TZl9J4VG)?wc;<!K1>%lkhst#e$mZw#b4RL$l>o!Q)a1nt*<6pfw*+Vqf)
zJOkJP*o?afhBm@U3e6Ajv^K@f=SN}EL+G8;FhS;wN%|ZhmjN_)%u+yB8X%XBp?<s#
zy6M>UoPkRfDR1fhfShh784j5%=tolW#L>g{<5KE}6+a}$X|N@~!F$RdKogY$BiD}D
zU=F9;oP0|XwYwNNP0-UU7=)Cc=<T`^x7&SQ^5rJ3jd9bI%mHh63usoL-7v_dJWlO)
zpJ!|rXi_w4qMy`>XU&$bM%zR3|NRe>=>^l%Ci8Q%q|Z#|cV|j#lk$$vlwM9Y|8kb}
z-)8e?7fAmz(tP|P>CYq0Cohsd9%<e&Q+g}a{Fe))gJaEsnbN^D^YII$!)fM6XGwpN
z&A+-xdU`@G>b`lZ`FFES_f0gvc#(8>`m;$W_~LZ)U9+US&M<#;k@VIX^FShawz(@`
z+IF@XO}==x`I(EPyQUC{?kVPtGo&xhG4IQlKFc&eeu3#%Q`aS<!UHp?_~8rCmk%y5
z-+qy_=OO}Zn@M%woJnlmF^gzI9=!kQKQRIMsd459&X#_8>H{hFpDo>LU4{(FWfF|%
zYV(=&-u98ne9vepm}JJ4%XP{0{+nd;%cG>1*!u^`=GR6^zfB={XNnnLcJU#5zr}1m
zGD_NRCirV+^YKyAtt06Dk0Z<{M@c>G{nHWVwWFo`M-qJJNb}93rAJfG!}~|6bM75Y
zZKu#*878x0!4Gjx->*s!!RY7P=UWNHOF;kL6#aWr;>*9ye=C9iqy)Id#dp)-QUX1C
z-W``;6ql#(I--Zgwe(`85Bf$V{`l*8s(%NG{{2Cxi*kya=)skF_UPXuL~$oQdilpE
zqdv-a!*9|9lgl0joB#BT;E9wi46Xo6W5o;kU3w^fqvuqf#6AUCNu%Hxj|gidwq8Mg
z0)z7JzNXiSBHtulu)oHh1A?&5_nktJLQJvtKa2AIpb|sHCMoOR0nrfFe=M)_g+K1b
z@@1kNOQ=ERqWS-LvL!rxlhdsnK3AlRL|P-#<sw}x(w~a-UXea5(%m9`S)_+VdR(L<
z&XU-3nn=$P>2#6K73m_8)`)buNY{$=ry{*qqz{X9w@6<W=^>FG7wL$zMf)N>N2Jq5
zI#;BNL|P-#<sw}x(w~a-UXea5(%m9`S)_+VdR(Nub;PH)>Tf*7H@RJ4%|IlQX|+$w
z%E_`@X=fzco}D`wFFt1i0N?%<jfa!|nxyYYeQmtNDiE;sIxIfT-y~Rp_VYL*TW{m_
z8Ufe8q(`5}|D(gFa{M(skxmHsi0^ZNZfE9$QKG+5;Ip+eP!0-sJN|wQJ-6^gDoo<|
zrwBSr1^j*ix17%bw1%Z;EG8b&zb+2HMZi1faXhv*#p?vv9m3xt=&*Gr;C~kIZXtKJ
zHUhi@9Vh%Z1pVJ|a?)-A$H6jtXnjCWH{ipK%RdDErgJ%-{`s1KcgMj$5b*f8V<Zfy
zNjhC>7kVU`mA=E^r^deDO{aeW;KaWk$LR3641YrGd*XDs7x3Zu_c8qOQsD|6b08fK
ze>Lza(k@vxfJbi|8J&qzygm9kgMT+>*Y#Qt0FG<lL!Lc=pN)Q%{D>Fn>)RzGhsVDW
zaKdkQar`ZU;(-MC=fK+2_hswfH)j?2<$w>z&rcJ;cLHvK*VM;LkddBFfIk8gcsTk~
z03Ysq!2cVI87t`5#@Q8r0y;kdoaE4X3Fn0N8t6F+_;^X?8*j)9_bg#~H7q};!(Ydl
zHb!SU;KT9nN&sJ+08W3@=@jr;cn%{g(VCu~2NU2Q1blqbq#^cIOMrhG0*&FmKm9U-
zgO2|FgBT|ETnqSc{pv^n?@9oFkKjpZk{)jf@={*{{Bba(!?kNo0M7xO#y9@^--{FA
z{{nE5gZ_PpR>9COp;sjTrgJ$!41@H(z}LSgu|(k85J(Qk=kx^dOB29562Q9>z~wZ-
zCw`-b9@=xF=TZje@5av>f+s=PRwER9WPp?Y#Lv^V1aw|Z08hab8cq%w3E+1nfFDf&
zFT}VEXUBdHIN6zaJ8&<9pDwMBvk!j|bR-v-Lyi!K2KaFNn<3ZX;O8fRD+%BMz%2&<
zrH{fbfRi5T-?P~+3U();L(B}v&v^;prGS&%vM=F;e<<kRBjE9JIGBLW@dWVG5MZHb
z$a4+g)*(<yx-J3!tqI^`v7Q)?elFm{(Vv|Fz8G+lv;MuMdfnRvT>swEcER)OfRo$`
zg`Tkea+FQR`e`_RW+Z@1rB%&-dzKGheq6bv&f~9KD$y4uXH_*dv2SM1!x>$@>!1Dp
z@vOR*=1P1IGJUu6zeFLc%2!{_zm+@oHP|`EGtuE#<6liZC&z^^L3h#@YcHU$LkB4w
zo;Ef6niyloFV_AyP>eB(FIkU$zqaceG~$HBnkws>U6+<l^WZ=7_H0k7w;rdr_7=aZ
zG@n3u_1=~i7b~u0AZH%F)Vdm93O~a$ApH54PAhe~>z3H3mFTCncxmxA7cBMqi+rt1
z>b=edmwpo_tN)XY49GS?cc!B|u15bi>`UF(=*z#Sg;+=aAL&R=9?st(D^Fb`l)&$4
zZLC|?>h(1FTH+Pw{}F@v;LqD!+2VDUK<#rq3zm5N&0epk(O2zdYHk>+Qh!b!I#A<l
zZa{zho@)96`nn~pbT`6P=d7xC0VB5o7ZkjWjb4v`1<Jk69&h8)x<;?7!QGIX<8(Jn
z&&k7QZov%twBsXZ+VmND`MJ~W(~z+fBrm5RuVDI&oC1OnUe5H~=><9Y)AO<kg`j!a
zIXN?Ovu8{rlJ<P|Vb96S&CQvX>%>#Hpv*%PE!$(yW)~+s{*_H$r=d4Ov-6u<8!v10
zmew^mmiy|eD;ul4&g$yAYCH?(mwN2e7F0G?`x@qX8zCm#=5TVA;wGC+C9L@pFM3!C
zlV0s@#w+W!zrj;g?`!n7z|L3uJWK0+ODgL<)u7PgscdbNs(cMi^|;MZO}2433=hmp
zou{(7xpE~$=x<&r)zJM9PjzcU!%9>!<S-g_{z0f<3T}j0@_6Pha1=W|&iO?i4|3RG
z@i-L$REiczo}w$}JBnR%B+oqeWwRY_&t-GxmO9HkWsccyCu&?dztor8)arLu70z?J
zX3r@v_vB{faS!qTkI}Z<*(7W9G-Ifo%h5@1b91B5gF7#kq??>?PYyPfrg6Tf^V>15
zQqMPY81Mk_6Hd52SbwLpD2G~w=gldIO&~Gh!4dA?VCYG)me3rF`6@QYJaDaEXz7Ad
zPn>wm7M1!7xZ|z!wG8KVopCkbR_wXFMonG4cS&o_u(hT^FEQVj$Jd4*wdZ(<p}Hz4
zU%l5=<(yI1;_>0uP&~G`y3$|CWoge7OxC~}cq<!*ZL`Q8PXTJ>&qv3Y0Omk|aqN^W
zGI~i}5M*!~mnLqA2O@(6la*uVjK*4{;fiZ*egZ#N0Nc^xoeN=nLsutxT$g!p8LY0+
z)7s)iVCAW5tMo8~;emEm)fQqxIcB>&_N-h{h<RUGk1JxFMWMFna=mx3CO3E+sv4RG
zVbNsu$HKOMPH6E%L~<i5#}zx<<MG!v`&M|s#ZrGQ%`jgx0=>a<^i;R_Jh<joUGL@9
z^7LwTjqI)*jMUQB2AH!URj(v{w@>4`#0NN$0uO4l=<=*)Z%vlRv$U<v(*)n+BkB29
zdX`f#4BIuWroOeMcF2einu&FdxVFdG8U!XM$n<kii!{;g1$xKoeM>Q2h8G7}a13gF
z-I6NkKqdS?2{blhxp}zQ*NpppF$ftb8rG(jF_4{^TFlL9Rph}iC-dP>R@7BvQdV)r
z{yLLBkIiC89lYmyT$p#4VOlq!gK>Q;EBoduG|aqXqxy9$L>wE9D;nY;)%7LI8w|50
ztKjSRe$G(yGiaczz5mqsLqfXM^L?4sL$hB);=1kmry~)l7PPABT2EE&wVs;Fy84*X
zKxZf<076;u9NqPk+D`X)e0*|=h;&$My?~U2&qRUkLOhU-Wzcj_39alzOFR_d17Xxq
zXjm~<QO3sLxtC=pd(3&^CS^%wHEdyvKi(*p`kROKd)&wyn4~zAJda><h6j<`fEgUT
z)-27VHC~w=Zri9}F)tCbo&%-`9w&h*;+)JtZ(CM2Ryj+m8U|@?jHqsj6Zr8w8Y~uo
z4>XGY@J7L@kx{Pn|Ly<=^8?C4PMsSn2_a|vF2De9UnLL`4`C3dQw&z`jrT1~0ditK
z#n<Zh_-ZJ8Tk0L+7?{Is_A*s5On))?g=zWHX*jfX&ytoFy`$Xme2uti=qTuu<jbP1
zp^a0VXxAejat_Uv%`4eN88iX1a&uT8eFac29!<Kcome*d$_9msZ2HmavB-;Q;9Kb`
zNv!<C>?(<f$+^7DgIJbJ^&89q>LxUZf*WYgaG}jm|2$+gzhasoaP?L;)Amdb^I-5|
ze%!SmJT9)XV$Z-b4Cap(VP%!rc#%8{8&_b<#<Ku7<r`3K&K#^{_?FoWtkLUfm6}jO
z|GK$><uS4vGY&(7?x8B<S=!)h6d?r0i2A56Gza(a%Ca(u=NtIj!QuATpX!5bQ>;th
zM1iuI0@bzns&aDCRm4RD{wz12E2c0fL)^KP)v~g|U%3P+Dzdazf5R_jc(ax^wr0^r
zB=%rdN?9?`lGeKV>Zx_rQWo|zyv<D#L#(ZAsg<&-S2ltuPyNljWI5tXEGP$MJSc1S
z)>l#m@zzxDCyH>uS$;2mRU?Z9f?3Tzwra}q){4b@Z8hrZIS{QvAlX*sZSrGRm=u;X
ziq*kX+9hTb`6{1N)Zd9Jv492`yOj-fRiNfW!}!Qz-0+rR_9X0IG*GB3wzdD|gziP*
z=on|~{Gq?8NROTtvfRLjevYU^vhZT8zfsiJQ*o_8M~|Jy>Hr5`O!(2;-zw_sseUg@
z$0uClL)-bsaW_e?-!1CvDcuvNM;yDx?ssvhB$eU?r)aVE_4{0UnvU~%dMKf`_5SPk
zx~>9@n$+9Z?}zEBejf}d?1|^U3Q)RxrPtT*Tj}XdqMpvbj;E(hD5twzdS1WJrKgN(
z;1K`Br_MiK*>fX4>5M#9U)(3t@0IEI$@KR1`g;FWQGYh0hGX}M{6$ao`)pL7?&QVS
z{|R6u6Cq|vvLZu|m3`ubZSbR?=j+g$@nWoRwek`@?a@0XD&Sa<J$m|c<c#(8dqR4;
zOq>^qYEq&8BGO+XHP+Y9!}S!$y@Q^3{{KhRkFiMuN{>kC?*tehoo^lXN4yY<USGeb
zqNgwFh$4+||M9r`8O<C~PbcdGFY4>#C$iG6xcWunUX7k^j^jVR{Z~-mXg~D(UV3WP
z8xm=J{dWMz5jN9pLecMgTCb<vfWGnEKwj_12PnW1b*#RAA2j1@*8c)^sf)tw#O~Q-
zi~8;QzyOCHy<MJ@q|vCX&rO2q_ldTw<`@=HU!Na(eO(W}gZjqyJ8$9jI%#6#$>2%s
zQ?IY5>2dY-`>2|z-%i90k6uqt&x)(BpWD~2;gxhdp_9<->G}UceS+!o)9)>`i~8~S
zKp*s+2LQpc2SFuCuYY<RT(56T<A#XU*tCXM+>3iR^w3{Dvf@YQNAK4tz;xd68hdIt
f@Ygb7PxS)5T|JL$0mIgR;#VAFT3m&=tn~i@#kR?9

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2026-01-14/2/main.cpp b/exams/AxelRubini/2026-01-14/2/main.cpp
new file mode 100644
index 0000000..6a558d5
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/main.cpp
@@ -0,0 +1,109 @@
+#include "include/Geometry.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+struct UAV {
+    Point3D pos;
+};
+
+double runOneSimAvoidance(
+    double T,
+    double H,
+    int N,
+    double L,
+    double V,
+    double D,
+    double R,
+    RandomGenerator &rng
+) {
+    std::vector<UAV> uavs(N);
+    for (int i = 0; i < N; ++i)
+        uavs[i].pos = {
+            rng.uniform(-L, L), rng.uniform(-L, L), rng.uniform(-L, L)
+        };
+
+    long long totalCollisions = 0;
+    double nextCheckTime = 0.0;
+
+    for (int t_idx = 0; (double)t_idx * T <= H + 1e-9; ++t_idx) {
+        double currentTime = (double)t_idx * T;
+
+        if (currentTime >= nextCheckTime - 1e-9) {
+            for (int i = 0; i < N; ++i) {
+                for (int j = i + 1; j < N; ++j) {
+                    if (uavs[i].pos.distanceTo(uavs[j].pos) <= D)
+                        totalCollisions++;
+                }
+            }
+            nextCheckTime += R;
+        }
+
+        std::vector<Point3D> nextPos(N);
+        for (int i = 0; i < N; ++i) {
+            double minVal = 1e18;
+            std::vector<Point3D> bestMoves;
+            for (int bit = 0; bit < 8; ++bit) {
+                double v1 = (bit & 1) ? V : -V;
+                double v2 = (bit & 2) ? V : -V;
+                double v3 = (bit & 4) ? V : -V;
+                Point3D pot = {
+                    uavs[i].pos.x + v1 * T,
+                    uavs[i].pos.y + v2 * T,
+                    uavs[i].pos.z + v3 * T
+                };
+
+                double val = 0;
+                for (int j = 0; j < N; ++j) {
+                    if (i == j)
+                        continue;
+                    val += std::pow((pot.x - uavs[j].pos.x) / (2.0 * L), 2) +
+                           std::pow((pot.y - uavs[j].pos.y) / (2.0 * L), 2) +
+                           std::pow((pot.z - uavs[j].pos.z) / (2.0 * L), 2);
+                }
+                if (val < minVal - 1e-12) {
+                    minVal = val;
+                    bestMoves = {pot};
+                } else if (std::abs(val - minVal) < 1e-12) {
+                    bestMoves.push_back(pot);
+                }
+            }
+            nextPos[i] =
+                bestMoves[rng.uniformInt(0, (int)bestMoves.size() - 1)];
+        }
+        for (int i = 0; i < N; ++i)
+            uavs[i].pos = nextPos[i];
+    }
+    return (double)totalCollisions / H;
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+
+    double T = parser.getDouble("T"), H = parser.getDouble("H"),
+           L = parser.getDouble("L"), V = parser.getDouble("V"),
+           D = parser.getDouble("D"), R = parser.getDouble("R");
+    int M = parser.getInt("M"), N = parser.getInt("N");
+
+    double totalRate = 0;
+    for (int i = 0; i < M; ++i)
+        totalRate += SELib::runOneSimAvoidance(T, H, N, L, V, D, R, rng);
+
+    std::ofstream outFile("results.txt");
+    outFile << "2026-01-14-Axel-Rubini-2158099" << std::endl;
+    outFile << "C " << totalRate / M << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2026-01-14/2/parameters.txt b/exams/AxelRubini/2026-01-14/2/parameters.txt
new file mode 100644
index 0000000..202b988
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/parameters.txt
@@ -0,0 +1,9 @@
+M 10
+N 1
+L 100
+A 10
+T 1.0
+R 2.0
+D 3.0
+H 1000
+V 2
diff --git a/exams/AxelRubini/2026-01-14/2/results.txt b/exams/AxelRubini/2026-01-14/2/results.txt
new file mode 100644
index 0000000..407d3bf
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/2/results.txt
@@ -0,0 +1,2 @@
+2026-01-14-Axel-Rubini-2158099
+C 396.958
diff --git a/exams/AxelRubini/2026-01-14/3/Makefile b/exams/AxelRubini/2026-01-14/3/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2026-01-14/3/include/DES.hpp b/exams/AxelRubini/2026-01-14/3/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/3/include/Decision.hpp b/exams/AxelRubini/2026-01-14/3/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/3/include/Dynamics.hpp b/exams/AxelRubini/2026-01-14/3/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/3/include/Geometry.hpp b/exams/AxelRubini/2026-01-14/3/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/3/include/IO.hpp b/exams/AxelRubini/2026-01-14/3/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/3/include/Inventory.hpp b/exams/AxelRubini/2026-01-14/3/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/3/include/Queue.hpp b/exams/AxelRubini/2026-01-14/3/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/3/include/Random.hpp b/exams/AxelRubini/2026-01-14/3/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/3/include/Stat.hpp b/exams/AxelRubini/2026-01-14/3/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/3/main b/exams/AxelRubini/2026-01-14/3/main
new file mode 100755
index 0000000000000000000000000000000000000000..98d7c59738fde93cbe0e83904f1416e9bb406c68
GIT binary patch
literal 81552
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
Zpv%?RV{xGCu5kq4(WEFD6fe2+{~s5&^r8R&

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2026-01-14/3/main.cpp b/exams/AxelRubini/2026-01-14/3/main.cpp
new file mode 100644
index 0000000..5fd35ee
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/main.cpp
@@ -0,0 +1,174 @@
+#include "include/DES.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include "include/Stat.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+class CustomerProcess : public DiscreteEventProcess {
+  public:
+    CustomerProcess(
+        int pid,
+        int S,
+        int P,
+        int Q,
+        double A,
+        double B,
+        MessageBus &bus,
+        RandomGenerator &rng
+    )
+        : pid_(pid), S_(S), P_(P), Q_(Q), A_(A), B_(B), bus_(bus), rng_(rng) {}
+    void initialize(double startTime) override {
+        nextTime_ = startTime + rng_.uniform(A_, B_);
+    }
+    double nextEventTime() const override { return nextTime_; }
+    void handleEvent(double currentTime) override {
+        Message m;
+        m.time = currentTime;
+        m.sender = pid_;
+        m.receiver = 100 + rng_.uniformInt(0, S_ - 1);
+        m.item = rng_.uniformInt(1, P_);
+        m.quantity = (double)rng_.uniformInt(1, Q_);
+        bus_.procToNet(pid_).push(m);
+        nextTime_ = currentTime + rng_.uniform(A_, B_);
+    }
+
+  private:
+    int pid_, S_, P_, Q_;
+    double A_, B_, nextTime_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+};
+
+class SupplierProcess : public DiscreteEventProcess {
+  public:
+    SupplierProcess(
+        int pid,
+        int S,
+        int P,
+        int Q,
+        double V,
+        double W,
+        MessageBus &bus,
+        RandomGenerator &rng
+    )
+        : pid_(pid), S_(S), P_(P), Q_(Q), V_(V), W_(W), bus_(bus), rng_(rng) {}
+    void initialize(double startTime) override {
+        nextTime_ = startTime + rng_.uniform(V_, W_);
+    }
+    double nextEventTime() const override { return nextTime_; }
+    void handleEvent(double currentTime) override {
+        Message m;
+        m.time = currentTime;
+        m.sender = pid_;
+        m.receiver = 100 + rng_.uniformInt(0, S_ - 1);
+        m.item = rng_.uniformInt(1, P_);
+        m.quantity = (double)rng_.uniformInt(0, Q_);
+        bus_.procToNet(pid_).push(m);
+        nextTime_ = currentTime + rng_.uniform(V_, W_);
+    }
+
+  private:
+    int pid_, S_, P_, Q_;
+    double V_, W_, nextTime_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+};
+
+class ServerProcess : public DiscreteEventProcess {
+  public:
+    ServerProcess(
+        int pid,
+        int C,
+        int F,
+        int P,
+        int Q,
+        MessageBus &bus,
+        RandomGenerator &rng,
+        long long &ms
+    )
+        : pid_(pid), C_(C), F_(F), P_(P), Q_(Q), bus_(bus), rng_(rng), ms_(ms) {
+        inv_.assign(P + 1, 0);
+    }
+    void initialize(double startTime) override {
+        for (int i = 1; i <= P_; ++i)
+            inv_[i] = rng_.uniformInt(0, Q_);
+        nextTime_ = startTime + 0.1;
+    }
+    double nextEventTime() const override { return nextTime_; }
+    void handleEvent(double currentTime) override {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            Message m = inbox.front();
+            inbox.pop();
+            bool isSupply = (m.sender >= C_ && m.sender < C_ + F_);
+            if (isSupply) {
+                inv_[m.item] += (int)m.quantity;
+            } else {
+                int req = (int)m.quantity;
+                if (inv_[m.item] < req)
+                    ms_++;
+                int prov = std::min(req, inv_[m.item]);
+                inv_[m.item] -= prov;
+            }
+        }
+        nextTime_ = currentTime + 0.1; // Periodic Polling
+    }
+
+  private:
+    int pid_, C_, F_, P_, Q_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+    long long &ms_;
+    double nextTime_;
+    std::vector<int> inv_;
+};
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+    double H = parser.getDouble("H");
+    int M = parser.getInt("M"), C = parser.getInt("C"), S = parser.getInt("S"),
+        P = parser.getInt("P"), F_suppliers = parser.getInt("F"),
+        Q = parser.getInt("Q");
+    double A = parser.getDouble("A"), B = parser.getDouble("B"),
+           V = parser.getDouble("V"), W = parser.getDouble("W");
+
+    SELib::Statistics stats;
+    for (int m = 0; m < M; ++m) {
+        SELib::MessageBus bus(200);
+        SELib::DiscreteEventSystem system;
+        long long ms = 0;
+        for (int i = 0; i < C; ++i)
+            system.emplaceProcess<SELib::CustomerProcess>(
+                i, S, P, Q, A, B, bus, rng
+            );
+        for (int i = 0; i < F_suppliers; ++i)
+            system.emplaceProcess<SELib::SupplierProcess>(
+                C + i, S, P, Q, V, W, bus, rng
+            );
+        for (int i = 0; i < S; ++i)
+            system.emplaceProcess<SELib::ServerProcess>(
+                100 + i, C, F_suppliers, P, Q, bus, rng, ms
+            );
+        system.emplaceProcess<SELib::NetworkRouter>(bus, rng, 0.01);
+        SELib::DiscreteEventSimulator sim(system);
+        sim.run(H);
+        stats.addSample((double)ms / H);
+    }
+    std::ofstream outFile("results.txt");
+    outFile << "2026-01-14-Axel-Rubini-2158099" << std::endl;
+    outFile << "R " << std::fixed << std::setprecision(6) << stats.mean()
+            << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2026-01-14/3/out.log b/exams/AxelRubini/2026-01-14/3/out.log
new file mode 100644
index 0000000..e69de29
diff --git a/exams/AxelRubini/2026-01-14/3/parameters.txt b/exams/AxelRubini/2026-01-14/3/parameters.txt
new file mode 100644
index 0000000..5033709
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/parameters.txt
@@ -0,0 +1,14 @@
+T 1.0
+M 100
+H 1000
+C 50
+S 10
+F 1
+Q 1
+A 1.5
+B 2.5
+V 3.1
+W 5.1
+P 1
+
+
diff --git a/exams/AxelRubini/2026-01-14/3/results.txt b/exams/AxelRubini/2026-01-14/3/results.txt
new file mode 100644
index 0000000..61192ca
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/3/results.txt
@@ -0,0 +1,2 @@
+2026-01-14-Axel-Rubini-2158099
+R 24.683300
diff --git a/exams/AxelRubini/2026-01-14/4/Makefile b/exams/AxelRubini/2026-01-14/4/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2026-01-14/4/include/DES.hpp b/exams/AxelRubini/2026-01-14/4/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/4/include/Decision.hpp b/exams/AxelRubini/2026-01-14/4/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/4/include/Dynamics.hpp b/exams/AxelRubini/2026-01-14/4/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/4/include/Geometry.hpp b/exams/AxelRubini/2026-01-14/4/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/4/include/IO.hpp b/exams/AxelRubini/2026-01-14/4/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/4/include/Inventory.hpp b/exams/AxelRubini/2026-01-14/4/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/4/include/Queue.hpp b/exams/AxelRubini/2026-01-14/4/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/4/include/Random.hpp b/exams/AxelRubini/2026-01-14/4/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/4/include/Stat.hpp b/exams/AxelRubini/2026-01-14/4/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/4/main b/exams/AxelRubini/2026-01-14/4/main
new file mode 100755
index 0000000000000000000000000000000000000000..1929b3ed537e306f423c400746a29defcdc50707
GIT binary patch
literal 81768
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2026-01-14/4/main.cpp b/exams/AxelRubini/2026-01-14/4/main.cpp
new file mode 100644
index 0000000..755b654
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/main.cpp
@@ -0,0 +1,202 @@
+#include "include/DES.hpp"
+#include "include/Decision.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include "include/Stat.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+class CustomerProcess : public DiscreteEventProcess {
+  public:
+    CustomerProcess(
+        int pid,
+        int S,
+        int P,
+        int Q,
+        double A,
+        double B,
+        MessageBus &bus,
+        RandomGenerator &rng
+    )
+        : pid_(pid), S_(S), P_(P), Q_(Q), A_(A), B_(B), bus_(bus), rng_(rng) {}
+    void initialize(double startTime) override {
+        nextTime_ = startTime + rng_.uniform(A_, B_);
+    }
+    double nextEventTime() const override { return nextTime_; }
+    void handleEvent(double currentTime) override {
+        Message m;
+        m.time = currentTime;
+        m.sender = pid_;
+        m.receiver = 100 + rng_.uniformInt(0, S_ - 1);
+        m.item = rng_.uniformInt(1, P_);
+        m.quantity = (double)rng_.uniformInt(1, Q_);
+        bus_.procToNet(pid_).push(m);
+        nextTime_ = currentTime + rng_.uniform(A_, B_);
+    }
+
+  private:
+    int pid_, S_, P_, Q_;
+    double A_, B_, nextTime_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+};
+
+class SupplierProcess : public DiscreteEventProcess {
+  public:
+    SupplierProcess(
+        int pid,
+        int S,
+        int P,
+        int Q,
+        double V,
+        double W,
+        MessageBus &bus,
+        RandomGenerator &rng
+    )
+        : pid_(pid), S_(S), P_(P), Q_(Q), V_(V), W_(W), bus_(bus), rng_(rng) {}
+    void initialize(double startTime) override {
+        nextTime_ = startTime + rng_.uniform(V_, W_);
+    }
+    double nextEventTime() const override { return nextTime_; }
+    void handleEvent(double currentTime) override {
+        Message m;
+        m.time = currentTime;
+        m.sender = pid_;
+        m.receiver = 100 + rng_.uniformInt(0, S_ - 1);
+        m.item = -rng_.uniformInt(1, P_);
+        m.quantity = (double)rng_.uniformInt(0, Q_);
+        bus_.procToNet(pid_).push(m);
+        nextTime_ = currentTime + rng_.uniform(V_, W_);
+    }
+
+  private:
+    int pid_, S_, P_, Q_;
+    double V_, W_, nextTime_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+};
+
+class ServerProcess : public DiscreteEventProcess {
+  public:
+    ServerProcess(
+        int pid,
+        int C,
+        int F,
+        int P,
+        int Q,
+        MessageBus &bus,
+        RandomGenerator &rng,
+        long long &ms
+    )
+        : pid_(pid), C_(C), F_(F), P_(P), Q_(Q), bus_(bus), rng_(rng), ms_(ms) {
+        inv_.assign(P + 1, 0);
+    }
+    void initialize(double startTime) override {
+        for (int i = 1; i <= P_; ++i)
+            inv_[i] = rng_.uniformInt(0, Q_);
+        nextTime_ = startTime + 0.1;
+    }
+    double nextEventTime() const override { return nextTime_; }
+    void handleEvent(double currentTime) override {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            Message m = inbox.front();
+            inbox.pop();
+            if (m.item < 0) {
+                inv_[-m.item] += (int)m.quantity;
+            } else {
+                int req = (int)m.quantity;
+                if (inv_[m.item] < req)
+                    ms_++;
+                int prov = std::min(req, inv_[m.item]);
+                inv_[m.item] -= prov;
+            }
+        }
+        nextTime_ = currentTime + 0.1;
+    }
+
+  private:
+    int pid_, C_, F_, P_, Q_;
+    MessageBus &bus_;
+    RandomGenerator &rng_;
+    long long &ms_;
+    double nextTime_;
+    std::vector<int> inv_;
+};
+
+double runMsims(
+    int F_count,
+    double H,
+    int M,
+    int C,
+    int S,
+    int P,
+    int Q,
+    double A,
+    double B,
+    double V,
+    double W,
+    RandomGenerator &rng
+) {
+    Statistics stats;
+    for (int m = 0; m < M; ++m) {
+        MessageBus bus(200);
+        DiscreteEventSystem system;
+        long long ms = 0;
+        for (int i = 0; i < C; ++i)
+            system.emplaceProcess<CustomerProcess>(i, S, P, Q, A, B, bus, rng);
+        for (int i = 0; i < F_count; ++i)
+            system.emplaceProcess<SupplierProcess>(
+                C + i, S, P, Q, V, W, bus, rng
+            );
+        for (int i = 0; i < S; ++i)
+            system.emplaceProcess<ServerProcess>(
+                100 + i, C, F_count, P, Q, bus, rng, ms
+            );
+        system.emplaceProcess<NetworkRouter>(bus, rng, 0.01);
+        DiscreteEventSimulator sim(system);
+        sim.run(H);
+        stats.addSample((double)ms / H);
+    }
+    return stats.mean();
+}
+
+} // namespace SELib
+
+int main() {
+    SELib::RandomGenerator rng(0);
+    SELib::ParameterParser parser;
+    if (!parser.parseFile("parameters.txt"))
+        return 1;
+    double H = parser.getDouble("H");
+    int M = parser.getInt("M"), C = parser.getInt("C"), S = parser.getInt("S"),
+        P = parser.getInt("P"), Q = parser.getInt("Q"), G = parser.getInt("G");
+    double A = parser.getDouble("A"), B = parser.getDouble("B"),
+           V = parser.getDouble("V"), W = parser.getDouble("W"),
+           a_cost = parser.getDouble("a"), b_cost = parser.getDouble("b");
+
+    int bestF = 0;
+    double minJ = 1e18, bestR = 0;
+    for (int i = 0; i < G; ++i) {
+        int F_cand = rng.uniformInt(0, 100);
+        double R = SELib::runMsims(F_cand, H, M, C, S, P, Q, A, B, V, W, rng);
+        double J = a_cost * F_cand + b_cost * R;
+        if (J < minJ) {
+            minJ = J;
+            bestF = F_cand;
+            bestR = R;
+        }
+    }
+    std::ofstream outFile("results.txt");
+    outFile << "2026-01-14-Axel-Rubini-2158099" << std::endl;
+    outFile << "R " << bestR << std::endl;
+    outFile << "F " << bestF << std::endl;
+    outFile << "J " << minJ << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2026-01-14/4/parameters.txt b/exams/AxelRubini/2026-01-14/4/parameters.txt
new file mode 100644
index 0000000..b9dcb6d
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/parameters.txt
@@ -0,0 +1,17 @@
+T 1.0
+M 10
+H 1000
+C 50
+S 1
+F 1
+Q 1
+A 1.5
+B 2.5
+V 1.1
+W 2.1
+P 1
+G 100
+a 0.9
+b 0.1
+
+
diff --git a/exams/AxelRubini/2026-01-14/4/results.txt b/exams/AxelRubini/2026-01-14/4/results.txt
new file mode 100644
index 0000000..12879f7
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/4/results.txt
@@ -0,0 +1,4 @@
+2026-01-14-Axel-Rubini-2158099
+R 24.8167
+F 0
+J 2.48167
diff --git a/exams/AxelRubini/2026-01-14/5/Makefile b/exams/AxelRubini/2026-01-14/5/Makefile
new file mode 100644
index 0000000..6910fc5
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/Makefile
@@ -0,0 +1,10 @@
+CC=g++
+CFLAGS=-std=c++23 -O3 -Wall
+
+all: main
+
+main: main.cpp
+	$(CC) $(CFLAGS) main.cpp -o main
+
+clean:
+	rm -f main *.o
diff --git a/exams/AxelRubini/2026-01-14/5/include/DES.hpp b/exams/AxelRubini/2026-01-14/5/include/DES.hpp
new file mode 100644
index 0000000..1706b8f
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/include/DES.hpp
@@ -0,0 +1,212 @@
+
+#pragma once
+
+#include "Random.hpp"
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ---------------------------------------------------------------------------
+// Messaggio
+// ---------------------------------------------------------------------------
+struct Message {
+  double time{0.0};
+  int sender{-1};
+  int receiver{-1};
+  int item{0};
+  double quantity{0.0};
+};
+
+// ---------------------------------------------------------------------------
+// Bus di messaggi: process -> network, network -> process
+// ---------------------------------------------------------------------------
+class MessageBus {
+public:
+  explicit MessageBus(std::size_t n = 0) { resize(n); }
+
+  void resize(std::size_t n) {
+    procToNet_.assign(n, {});
+    netToProc_.assign(n, {});
+  }
+
+  std::size_t size() const { return procToNet_.size(); }
+
+  std::queue<Message> &procToNet(int pid) { return procToNet_.at(pid); }
+  std::queue<Message> &netToProc(int pid) { return netToProc_.at(pid); }
+  const std::queue<Message> &procToNet(int pid) const {
+    return procToNet_.at(pid);
+  }
+  const std::queue<Message> &netToProc(int pid) const {
+    return netToProc_.at(pid);
+  }
+
+private:
+  std::vector<std::queue<Message>> procToNet_;
+  std::vector<std::queue<Message>> netToProc_;
+};
+
+// ---------------------------------------------------------------------------
+// Processo base a eventi discreti
+// ---------------------------------------------------------------------------
+class DiscreteEventProcess {
+public:
+  virtual ~DiscreteEventProcess() = default;
+  virtual void initialize(double startTime) = 0;
+  virtual double nextEventTime() const = 0;
+  virtual void handleEvent(double currentTime) = 0;
+};
+
+// ---------------------------------------------------------------------------
+// NetworkRouter: inoltra i messaggi P->N->P
+// ---------------------------------------------------------------------------
+class NetworkRouter : public DiscreteEventProcess {
+public:
+  NetworkRouter(MessageBus &bus, RandomGenerator &rng, double scanPeriod = 0.1)
+      : bus_(bus), rng_(rng), scanPeriod_(scanPeriod), time_(0.0),
+        nextScanTime_(0.0), scanned_(0) {}
+
+  void initialize(double startTime) override {
+    time_ = startTime;
+    nextScanTime_ = startTime + scanPeriod_;
+
+    const int n = static_cast<int>(bus_.size());
+    if (n <= 0) {
+      throw std::runtime_error(
+          "NetworkRouter: no processes configured in MessageBus");
+    }
+
+    scanner_.resize(n);
+    for (int i = 0; i < n; ++i) {
+      scanner_[i] = i;
+    }
+    reshuffleScanner();
+    scanned_ = 0;
+  }
+
+  double nextEventTime() const override { return nextScanTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextScanTime_)
+      return;
+
+    const int n = static_cast<int>(scanner_.size());
+    if (n == 0)
+      return;
+
+    if (scanned_ >= n) {
+      scanned_ = 0;
+      reshuffleScanner();
+    }
+
+    const int channel = scanner_[scanned_++];
+    auto &fromQueue = bus_.procToNet(channel);
+
+    if (!fromQueue.empty()) {
+      Message m = fromQueue.front();
+      fromQueue.pop();
+
+      if (m.receiver < 0 || m.receiver >= static_cast<int>(bus_.size())) {
+        throw std::runtime_error("NetworkRouter: invalid receiver index");
+      }
+
+      bus_.netToProc(m.receiver).push(m);
+    }
+
+    nextScanTime_ = currentTime + scanPeriod_;
+  }
+
+private:
+  void reshuffleScanner() {
+    auto &eng = rng_.engine(); // serve engine() in RandomGenerator
+    std::shuffle(scanner_.begin(), scanner_.end(), eng);
+  }
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double scanPeriod_;
+  double time_;
+  double nextScanTime_;
+  std::vector<int> scanner_;
+  int scanned_;
+};
+
+// ---------------------------------------------------------------------------
+// Sistema DES: collezione di processi
+// ---------------------------------------------------------------------------
+class DiscreteEventSystem {
+public:
+  template <typename Proc, typename... Args>
+  Proc &emplaceProcess(Args &&...args) {
+    auto ptr = std::make_unique<Proc>(std::forward<Args>(args)...);
+    Proc &ref = *ptr;
+    processes_.push_back(std::move(ptr));
+    return ref;
+  }
+
+  void initialize(double startTime = 0.0) {
+    for (auto &p : processes_) {
+      p->initialize(startTime);
+    }
+  }
+
+  double nextEventTime() const {
+    if (processes_.empty()) {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    double tMin = std::numeric_limits<double>::infinity();
+    for (const auto &p : processes_) {
+      double t = p->nextEventTime();
+      if (t < tMin)
+        tMin = t;
+    }
+    return tMin;
+  }
+
+  void handleEvent(double currentTime) {
+    for (auto &p : processes_) {
+      if (p->nextEventTime() <= currentTime) {
+        p->handleEvent(currentTime);
+      }
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<DiscreteEventProcess>> processes_;
+};
+
+// ---------------------------------------------------------------------------
+// Simulatore DES
+// ---------------------------------------------------------------------------
+class DiscreteEventSimulator {
+public:
+  explicit DiscreteEventSimulator(DiscreteEventSystem &system)
+      : system_(system), currentTime_(0.0) {}
+
+  void run(double horizon) {
+    system_.initialize(0.0);
+    currentTime_ = 0.0;
+
+    while (currentTime_ < horizon) {
+      double nextTime = system_.nextEventTime();
+      if (nextTime == std::numeric_limits<double>::infinity())
+        break;
+      currentTime_ = nextTime;
+      system_.handleEvent(currentTime_);
+    }
+  }
+
+  double currentTime() const { return currentTime_; }
+
+private:
+  DiscreteEventSystem &system_;
+  double currentTime_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/5/include/Decision.hpp b/exams/AxelRubini/2026-01-14/5/include/Decision.hpp
new file mode 100644
index 0000000..4d37cf0
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/include/Decision.hpp
@@ -0,0 +1,266 @@
+#pragma once
+
+#include "Random.hpp"
+#include "Stat.hpp"
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 7. MARKOV CHAIN
+// ============================================================================
+
+// MarkovChain: Implements a discrete-time Markov chain.
+// Purpose:
+//  - Simulates stochastic processes with defined states and transition
+//  probabilities.
+//  - Useful in modeling random systems and computing related probabilities.
+// Usage:
+//  MarkovChain mc(3, rng);
+//  mc.setTransition(0, 1, 0.5);
+//  mc.setTransition(0, 2, 0.5);
+//  mc.setState(0);
+//  int nextState = mc.step();
+class MarkovChain {
+private:
+  int numStates;
+  std::vector<std::vector<double>> transitionMatrix;
+  int currentState;
+  RandomGenerator &rng;
+
+public:
+  MarkovChain(int states, RandomGenerator &generator)
+      : numStates(states), currentState(0), rng(generator) {
+    transitionMatrix.resize(states, std::vector<double>(states, 0.0));
+  }
+
+  void setTransition(int from, int to, double probability) {
+    if (from >= 0 && from < numStates && to >= 0 && to < numStates) {
+      transitionMatrix[from][to] = probability;
+    }
+  }
+
+  void setState(int state) {
+    if (state >= 0 && state < numStates) {
+      currentState = state;
+    }
+  }
+
+  int getState() const { return currentState; }
+
+  int step() {
+    currentState = rng.discrete(transitionMatrix[currentState]);
+    return currentState;
+  }
+
+  double getTransitionProb(int from, int to) const {
+    return transitionMatrix[from][to];
+  }
+
+  double expectedSojournTime(int state, double timeStep = 1.0) const {
+    double pii = transitionMatrix[state][state];
+    if (pii >= 1.0)
+      return std::numeric_limits<double>::infinity();
+    return timeStep / (1.0 - pii);
+  }
+};
+
+// ============================================================================
+// 8. MDP
+// ============================================================================
+
+// MDP: Implements a Markov Decision Process (MDP) model.
+// Purpose:
+//  - Simulate decision-making processes with states, transitions, and
+//  associated costs.
+//  - Calculate the total cost to reach a target state from a starting state.
+// Usage:
+//  - Add transitions between states with associated probabilities and costs
+//  using `addTransition`.
+//  - Use `step` to simulate a single transition and calculate its cost.
+//  - Use `simulate` to estimate the total cost from a start to an end state.
+class MDP {
+private:
+  int numStates;
+  std::map<int, std::vector<std::pair<int, std::pair<double, double>>>>
+      transitions;
+  RandomGenerator &rng;
+
+public:
+  MDP(int states, RandomGenerator &generator)
+      : numStates(states), rng(generator) {}
+
+  void addTransition(int from, int to, double probability, double cost) {
+    transitions[from].push_back({to, {probability, cost}});
+  }
+
+  std::pair<int, double> step(int currentState) {
+    if (transitions.find(currentState) == transitions.end()) {
+      return {currentState, 0.0};
+    }
+
+    std::vector<double> probs;
+    for (const auto &t : transitions[currentState]) {
+      probs.push_back(t.second.first);
+    }
+
+    int idx = rng.discrete(probs);
+    int nextState = transitions[currentState][idx].first;
+    double cost = transitions[currentState][idx].second.second;
+
+    return {nextState, cost};
+  }
+
+  double simulate(int startState, int endState) {
+    int state = startState;
+    double totalCost = 0.0;
+    int maxSteps = 100000;
+
+    for (int step = 0; step < maxSteps && state != endState; step++) {
+      auto [nextState, cost] = this->step(state);
+      totalCost += cost;
+      state = nextState;
+    }
+    return totalCost;
+  }
+};
+
+// ============================================================================
+// 10. MONTE CARLO SIMULATOR
+// ============================================================================
+
+// MonteCarloSimulator: A utility for running Monte Carlo simulations.
+// Purpose:
+//  - Estimate statistical metrics through repeated random sampling.
+//  - Provides methods to calculate mean results and probabilities of events.
+// Usage:
+//  MonteCarloSimulator simulator(1000);
+//  double estimate = simulator.estimate([](int) { return some_random_value; });
+//  double probability = simulator.estimateProbability([](int) { return
+//  some_event_occurs; });
+class MonteCarloSimulator {
+private:
+  Statistics stats;
+  int numSimulations;
+
+public:
+  MonteCarloSimulator(int simulations = 1000) : numSimulations(simulations) {}
+
+  template <typename SimFunc> double estimate(SimFunc simulation) {
+    stats.clear();
+    for (int i = 0; i < numSimulations; i++) {
+      double result = simulation(i);
+      stats.addSample(result);
+    }
+    return stats.mean();
+  }
+
+  template <typename SimFunc> double estimateProbability(SimFunc simulation) {
+    int successes = 0;
+    for (int i = 0; i < numSimulations; i++) {
+      if (simulation(i))
+        successes++;
+    }
+    return static_cast<double>(successes) / numSimulations;
+  }
+
+  const Statistics &getStatistics() const { return stats; }
+};
+
+// ============================================================================
+// 13. OPTIMIZATION UTILITIES
+// ============================================================================
+
+// Optimizer: Utility class offering optimization techniques such as random
+// search and grid search. Purpose:
+//  - Explore parameter spaces to maximize or minimize an objective function.
+//  - Supports both continuous and discrete search spaces.
+// Usage:
+//  - Use `randomSearch` for stochastic optimization over a defined range.
+//  - Use `gridSearch` for systematic exploration in evenly spaced steps.
+// Example:
+//  auto [bestParam, bestValue] = Optimizer::randomSearch(objectiveFunction,
+//  0.0, 10.0, 100, rng); auto [bestInt, bestIntValue] =
+//  Optimizer::randomSearchInt(objectiveFunction, 0, 10, 50, rng);
+class Optimizer {
+public:
+  template <typename ObjFunc>
+  static std::pair<double, double>
+  randomSearch(ObjFunc objective, double minValue, double maxValue, int budget,
+               RandomGenerator &rng, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    for (int i = 0; i < budget; i++) {
+      double param = rng.uniform(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<int, double>
+  randomSearchInt(ObjFunc objective, int minValue, int maxValue, int budget,
+                  RandomGenerator &rng, bool maximize = true) {
+    int bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+
+    if (budget <= 0) {
+      throw std::invalid_argument("randomSearchInt: budget must be positive.");
+    }
+
+    if (minValue >= maxValue) {
+      throw std::invalid_argument(
+          "randomSearchInt: minValue must be less than maxValue.");
+    }
+
+    for (int i = 0; i < budget; i++) {
+      int param = rng.uniformInt(minValue, maxValue);
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+
+  template <typename ObjFunc>
+  static std::pair<double, double> gridSearch(ObjFunc objective,
+                                              double minValue, double maxValue,
+                                              int steps, bool maximize = true) {
+    double bestParam = minValue;
+    double bestValue = maximize ? -std::numeric_limits<double>::infinity()
+                                : std::numeric_limits<double>::infinity();
+    double stepSize = (maxValue - minValue) / steps;
+
+    if (steps <= 0) {
+      throw std::invalid_argument("gridSearch: steps must be positive.");
+    }
+
+    for (int i = 0; i <= steps; i++) {
+      double param = minValue + i * stepSize;
+      double value = objective(param);
+
+      if ((maximize && value > bestValue) || (!maximize && value < bestValue)) {
+        bestValue = value;
+        bestParam = param;
+      }
+    }
+    return {bestParam, bestValue};
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/5/include/Dynamics.hpp b/exams/AxelRubini/2026-01-14/5/include/Dynamics.hpp
new file mode 100644
index 0000000..044176a
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/include/Dynamics.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+namespace SELib {
+// ============================================================================
+// 3. ODE SOLVER (Runge-Kutta 4th order)
+// ============================================================================
+
+using StateVector = std::vector<double>;
+using DerivativeFunction = std::function<StateVector(
+    double, const StateVector &, const StateVector &)>;
+
+// ODESolver: Implements numerical methods for solving Ordinary Differential
+// Equations (ODEs). Purpose:
+//  - Provides tools for simulating dynamic systems modeled by ODEs.
+//  - Includes methods such as Runge-Kutta 4th order and Euler's method for
+//  integration.
+// Usage:
+//  - Pass a derivative function that defines the ODE system.
+//  - Use `rk4Step` for higher accuracy or `eulerStep` for simpler systems.
+// Example:
+//  StateVector nextState = ODESolver::rk4Step(0.0, currentState, controlInputs,
+//  dt, dynamicsFunction);
+class ODESolver {
+public:
+  static StateVector rk4Step(double t, const StateVector &x,
+                             const StateVector &u, double dt,
+                             DerivativeFunction f) {
+    StateVector k1 = f(t, x, u);
+    StateVector x2 = addScaled(x, k1, dt / 2.0);
+    StateVector k2 = f(t + dt / 2.0, x2, u);
+    StateVector x3 = addScaled(x, k2, dt / 2.0);
+    StateVector k3 = f(t + dt / 2.0, x3, u);
+    StateVector x4 = addScaled(x, k3, dt);
+    StateVector k4 = f(t + dt, x4, u);
+
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += (dt / 6.0) * (k1[i] + 2.0 * k2[i] + 2.0 * k3[i] + k4[i]);
+    }
+    return xNew;
+  }
+
+  static StateVector eulerStep(double t, const StateVector &x,
+                               const StateVector &u, double dt,
+                               DerivativeFunction f) {
+    StateVector dx = f(t, x, u);
+    StateVector xNew = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      xNew[i] += dx[i] * dt;
+    }
+    return xNew;
+  }
+
+private:
+  static StateVector addScaled(const StateVector &x, const StateVector &dx,
+                               double scale) {
+    StateVector result = x;
+    for (size_t i = 0; i < x.size(); i++) {
+      result[i] += dx[i] * scale;
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// 4. PID CONTROLLER
+// ============================================================================
+
+// PIDController: Implements a Proportional-Integral-Derivative (PID)
+// controller. Purpose:
+//  - Automatically adjusts a control signal to minimize the difference between
+//  a desired setpoint and a measured value.
+//  - Used in control systems to regulate processes like temperature, speed, or
+//  position.
+// Usage:
+//  - Create an instance with proportional (Kp), integral (Ki), and derivative
+//  (Kd) gains, along with a time step.
+//  - Use `compute` to calculate the control signal based on the setpoint and
+//  measurement.
+// Example:
+//  PIDController pid(1.0, 0.1, 0.01, 0.1);
+//  double controlSignal = pid.compute(desiredValue, actualValue);
+class PIDController {
+private:
+  double kp, ki, kd;
+  double integral;
+  double prevError;
+  double dt;
+
+public:
+  PIDController(double Kp, double Ki, double Kd, double timeStep)
+      : kp(Kp), ki(Ki), kd(Kd), integral(0), prevError(0), dt(timeStep) {}
+
+  double compute(double setpoint, double measurement) {
+    double error = setpoint - measurement;
+    integral += error * dt;
+    double derivative = (error - prevError) / dt;
+    prevError = error;
+    return kp * error + ki * integral + kd * derivative;
+  }
+
+  void reset() {
+    integral = 0;
+    prevError = 0;
+  }
+
+  void setGains(double Kp, double Ki, double Kd) {
+    kp = Kp;
+    ki = Ki;
+    kd = Kd;
+  }
+};
+
+// ============================================================================
+// 5. CONTINUOUS TIME SIMULATION
+// ============================================================================
+
+// ContinuousTimeSimulation: A base class for simulating continuous-time dynamic
+// systems. Purpose:
+//  - Provides a framework for simulating systems characterized by continuous
+//  dynamics over time.
+//  - Integrates system dynamics using a Runge-Kutta 4th order solver.
+// Usage:
+//  - Derive from this class and implement the `dynamics`, `computeControl`,
+//  `initialize`, and `finalize` methods.
+//  - Customize the `onStep` method for per-step side effects, if required.
+// Example:
+//  class MySimulation : public ContinuousTimeSimulation {
+//    // Implement the required virtual methods.
+//  };
+//  MySimulation sim(dt, horizon, initialState);
+//  sim.run();
+class ContinuousTimeSimulation {
+protected:
+  double currentTime;
+  double timeStep;
+  double horizon;
+  StateVector state;
+  StateVector control;
+
+public:
+  ContinuousTimeSimulation(double dt, double H, const StateVector &initialState)
+      : currentTime(0.0), timeStep(dt), horizon(H), state(initialState) {
+    control.resize(initialState.size(), 0.0);
+  }
+
+  virtual ~ContinuousTimeSimulation() = default;
+
+  virtual StateVector dynamics(double t, const StateVector &x,
+                               const StateVector &u) = 0;
+  virtual StateVector computeControl(double t, const StateVector &x) = 0;
+  virtual void initialize() = 0;
+  virtual void onStep() {}
+  virtual void finalize() = 0;
+
+  void run() {
+    initialize();
+    while (currentTime < horizon) {
+      control = computeControl(currentTime, state);
+      state = ODESolver::rk4Step(
+          currentTime, state, control, timeStep,
+          [this](double t, const StateVector &x, const StateVector &u) {
+            return this->dynamics(t, x, u);
+          });
+      currentTime += timeStep;
+      onStep();
+    }
+    finalize();
+  }
+
+  double getCurrentTime() const { return currentTime; }
+  const StateVector &getState() const { return state; }
+  const StateVector &getControl() const { return control; }
+};
+
+// ============================================================================
+// 6. SAMPLE AND HOLD
+// ============================================================================
+
+// SampleAndHold: A utility to store a value and update it periodically.
+// Purpose:
+//  - Maintain a value that gets updated periodically based on a time interval.
+//  - Useful for sampling data and ensuring updates happen at fixed intervals.
+// Usage:
+//  SampleAndHold<int> sampler(5.0, 0);
+//  if (sampler.shouldUpdate(currentTime)) {
+//    sampler.update(currentTime, newValue);
+//  }
+//  int currentValue = sampler.getValue();
+template <typename T> class SampleAndHold {
+private:
+  T value;
+  double lastUpdateTime;
+  double samplePeriod;
+
+public:
+  SampleAndHold(double period, const T &initialValue = T())
+      : value(initialValue), lastUpdateTime(0), samplePeriod(period) {}
+
+  bool shouldUpdate(double currentTime) const {
+    return (currentTime - lastUpdateTime) >= samplePeriod;
+  }
+
+  void update(double currentTime, const T &newValue) {
+    value = newValue;
+    lastUpdateTime = currentTime;
+  }
+
+  const T &getValue() const { return value; }
+  void reset() { lastUpdateTime = 0; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/5/include/Geometry.hpp b/exams/AxelRubini/2026-01-14/5/include/Geometry.hpp
new file mode 100644
index 0000000..525a91d
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/include/Geometry.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 14. GEOMETRIC UTILITIES
+// ============================================================================
+
+// Point2D: Represents a point or vector in 2D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point2D p1(1.0, 2.0), p2(2.0, 3.0);
+//  double dist = p1.distanceTo(p2);
+//  Point2D sum = p1 + p2;
+struct Point2D {
+  double x, y;
+
+  Point2D(double x_ = 0, double y_ = 0) : x(x_), y(y_) {}
+
+  double distanceTo(const Point2D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+  }
+
+  Point2D operator+(const Point2D &other) const {
+    return Point2D(x + other.x, y + other.y);
+  }
+
+  Point2D operator-(const Point2D &other) const {
+    return Point2D(x - other.x, y - other.y);
+  }
+};
+
+// Point3D: Represents a point or vector in 3D space.
+// Purpose:
+//  - Provides basic operations like addition, subtraction, and distance
+//  calculation.
+// Usage:
+//  Point3D p1(1.0, 2.0, 3.0), p2(2.0, 3.0, 4.0);
+//  double dist = p1.distanceTo(p2);
+//  Point3D sum = p1 + p2;
+struct Point3D {
+  double x, y, z;
+
+  Point3D(double x_ = 0, double y_ = 0, double z_ = 0) : x(x_), y(y_), z(z_) {}
+
+  double distanceTo(const Point3D &other) const {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    double dz = z - other.z;
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  Point3D operator+(const Point3D &other) const {
+    return Point3D(x + other.x, y + other.y, z + other.z);
+  }
+
+  Point3D operator-(const Point3D &other) const {
+    return Point3D(x - other.x, y - other.y, z - other.z);
+  }
+};
+
+// ============================================================================
+// 19. COLLISION DETECTOR
+// ============================================================================
+
+// CollisionDetector: A utility class for detecting collisions between points
+// in space. Purpose:
+//  - Counts the number of collisions within a given distance threshold.
+//  - Retrieves pairs of colliding points.
+// Usage:
+//  std::vector<Point2D> points = {Point2D(0, 0), Point2D(1, 1)};
+//  int numCollisions = CollisionDetector::countCollisions(points, 1.5);
+//  auto collidingPairs = CollisionDetector::getCollidingPairs(points, 1.5);
+class CollisionDetector {
+public:
+  template <typename PointType>
+  static int countCollisions(const std::vector<PointType> &positions,
+                             double threshold) {
+    int collisions = 0;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          collisions++;
+        }
+      }
+    }
+    return collisions;
+  }
+
+  template <typename PointType>
+  static std::vector<std::pair<int, int>>
+  getCollidingPairs(const std::vector<PointType> &positions, double threshold) {
+    std::vector<std::pair<int, int>> pairs;
+    for (size_t i = 0; i < positions.size(); i++) {
+      for (size_t j = i + 1; j < positions.size(); j++) {
+        if (positions[i].distanceTo(positions[j]) <= threshold) {
+          pairs.push_back({i, j});
+        }
+      }
+    }
+    return pairs;
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/5/include/IO.hpp b/exams/AxelRubini/2026-01-14/5/include/IO.hpp
new file mode 100644
index 0000000..1a79cc6
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/include/IO.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace SELib {
+
+// ============================================================================
+// 11. PARAMETER PARSER
+// ============================================================================
+
+// ParameterParser: A utility to parse and retrieve parameters from
+// configuration files. Purpose:
+//  - Reads a file and stores key-value pairs for parameters.
+//  - Allows retrieval of parameters as integers, doubles, or strings.
+//  - Provides structured data for advanced parsing.
+// Usage:
+//  ParameterParser parser;
+//  if (parser.parseFile("config.txt")) {
+//      int param = parser.getInt("example_key", 42);
+//  }
+class ParameterParser {
+private:
+  std::map<std::string, std::string> params;
+  std::vector<std::vector<std::string>> structuredData;
+
+public:
+  bool parseFile(const std::string &filename) {
+    std::ifstream file(filename);
+    if (!file.is_open())
+      return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+      if (line.empty())
+        continue;
+
+      std::istringstream iss(line);
+      std::string key;
+      iss >> key;
+
+      std::string value;
+      std::getline(iss, value);
+      if (!value.empty() && value[0] == ' ') {
+        value = value.substr(1);
+      }
+
+      params[key] = value;
+
+      std::vector<std::string> tokens;
+      std::istringstream tokenStream(line);
+      std::string token;
+      while (tokenStream >> token) {
+        tokens.push_back(token);
+      }
+      structuredData.push_back(tokens);
+    }
+    return true;
+  }
+
+  int getInt(const std::string &key, int defaultValue = 0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stoi(it->second);
+    }
+    return defaultValue;
+  }
+
+  double getDouble(const std::string &key, double defaultValue = 0.0) const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return std::stod(it->second);
+    }
+    return defaultValue;
+  }
+
+  std::string getString(const std::string &key,
+                        const std::string &defaultValue = "") const {
+    auto it = params.find(key);
+    if (it != params.end()) {
+      return it->second;
+    }
+    return defaultValue;
+  }
+
+  const std::vector<std::vector<std::string>> &getStructuredData() const {
+    return structuredData;
+  }
+
+  bool hasKey(const std::string &key) const {
+    return params.find(key) != params.end();
+  }
+};
+
+// ============================================================================
+// 12. OUTPUT WRITER
+// ============================================================================
+
+// OutputWriter: A utility class for writing data to output files.
+// Purpose:
+//  - Simplifies the process of writing data to files.
+//  - Supports writing lines, key-value pairs, and managing file headers.
+// Usage:
+//  OutputWriter writer;
+//  if (writer.open("output.txt", "Header Info")) {
+//    writer.writeLine("Example Line");
+//    writer.writeKeyValue("Key", 42.0);
+//    writer.close();
+//  }
+class OutputWriter {
+private:
+  std::ofstream file;
+
+public:
+  bool open(const std::string &filename, const std::string &header) {
+    file.open(filename);
+    if (!file.is_open())
+      return false;
+    file << header << std::endl;
+    return true;
+  }
+
+  template <typename T> void writeLine(const T &value) {
+    file << value << std::endl;
+  }
+
+  template <typename T, typename... Args>
+  void writeLine(const T &first, const Args &...args) {
+    file << first << " ";
+    writeLine(args...);
+  }
+
+  void writeKeyValue(const std::string &key, double value, int precision = 2) {
+    file << key << " " << std::fixed << std::setprecision(precision) << value
+         << std::endl;
+  }
+
+  void close() {
+    if (file.is_open()) {
+      file.close();
+    }
+  }
+
+  ~OutputWriter() { close(); }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/5/include/Inventory.hpp b/exams/AxelRubini/2026-01-14/5/include/Inventory.hpp
new file mode 100644
index 0000000..c82d776
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/include/Inventory.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include "DES.hpp"
+#include "Random.hpp"
+#include <cstddef>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 16. CUSTOMER MODEL
+// ============================================================================
+
+// Customer: Represents a customer model in a simulation.
+// Purpose:
+//  - Simulates customer requests over time.
+//  - Generates random requests for products at specific intervals.
+// Usage:
+//  Customer customer(5.0, 10.0, 3, rng);
+//  int productId = customer.step(0.1); // Simulates a time step of 0.1 seconds.
+class Customer {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer(double A, double B, int N, RandomGenerator &generator)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator) {
+    nextRequestTime = rng.uniform(A, B);
+  }
+
+  int step(double dt) {
+    nextRequestTime -= dt;
+    if (nextRequestTime <= 0) {
+      nextRequestTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+};
+class Customer_Event_Driven {
+private:
+  double nextRequestTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Customer_Event_Driven(double A, double B, int N, RandomGenerator &generator,
+                        double nextRequestTime)
+      : minInterval(A), maxInterval(B), numProducts(N), rng(generator),
+        nextRequestTime(nextRequestTime) {}
+
+  int step_event_driven(double *current_time) {
+    if (*current_time >= nextRequestTime) {
+      nextRequestTime = *current_time + rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  double getNextRequestTime() { return nextRequestTime; };
+};
+
+// ============================================================================
+// 17. SERVER MODEL
+// ============================================================================
+
+// Server: Represents a server in a simulated environment.
+// Purpose:
+//  - Handles product requests and manages inventory.
+//  - Simulates server busy time during request processing.
+// Usage:
+//  Server server(numProducts, maxInventory, processingTimeNormal,
+//  processingTimeSupplier, rng); int result =
+//  server.processRequest(productId, needsSupply);
+//  server.addInventory(productId, quantityAdded);
+class Server {
+private:
+  std::vector<int> inventory;
+  int busyTime;
+  int processingTimeNormal;
+  int processingTimeSupplier;
+  RandomGenerator *rng;
+
+public:
+  Server(int numProducts, int K, int F, int G, RandomGenerator &rng)
+      : inventory(numProducts + 1, 0), busyTime(0), processingTimeNormal(F),
+        processingTimeSupplier(G), rng(&rng) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+
+  bool isBusy() const { return busyTime > 0; }
+
+  void decrementBusyTime() {
+    if (busyTime > 0)
+      busyTime--;
+  }
+
+  int processRequest(int productId, bool needsSupply) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return productId;
+    } else {
+      busyTime = needsSupply ? processingTimeSupplier : processingTimeNormal;
+      return -productId;
+    }
+  }
+
+  int processRequest2(int productId, double supply_prob, int min_prod_refill,
+                      int max_prod_refill) {
+    if (inventory[productId] > 0) {
+      inventory[productId]--;
+      busyTime = processingTimeNormal;
+      return productId;
+    } else {
+      if (rng->bernoulli(supply_prob)) {
+        int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+        inventory[productId] += refill_amount;
+      }
+      busyTime = processingTimeSupplier;
+      return -productId;
+    }
+  }
+
+  void addInventory(int productId, int quantity) {
+    inventory[productId] += quantity;
+  }
+
+  int getInventory(int productId) const { return inventory[productId]; }
+};
+// ============================================================================
+// 17.5 SERVER-EVENT-DRIVEN
+// ============================================================================
+class Server_Event_Driven {
+private:
+  std::vector<int> inventory;
+  RandomGenerator *rng;
+  double next_step_time;
+  double min_interval;
+  double max_interval;
+
+public:
+  Server_Event_Driven(int numProducts, int K, double min_interval,
+                      double max_interval, RandomGenerator &rng,
+                      double nextStepTime)
+      : inventory(numProducts + 1, 0), rng(&rng), min_interval(min_interval),
+        max_interval(max_interval), next_step_time(nextStepTime) {
+    for (int i = 1; i <= numProducts; i++) {
+      inventory[i] = rng.uniformInt(0, K);
+    }
+  }
+  int processRequestEventDriven(double current_time, int productId,
+                                double supply_prob, int min_prod_refill,
+                                int max_prod_refill) {
+    if (current_time >= next_step_time) {
+      if (inventory[productId] > 0) {
+        inventory[productId]--;
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+        return productId;
+      } else {
+        if (rng->bernoulli(supply_prob)) {
+          int refill_amount = rng->uniformInt(min_prod_refill, max_prod_refill);
+          inventory[productId] += refill_amount;
+        }
+        next_step_time =
+            current_time +
+            rng->uniform(
+                min_interval,
+                max_interval); // assuming processing time normal is 1.0
+
+        return -productId;
+      }
+    } else {
+      return 0;
+    }
+  }
+  double getNextStepTime() { return next_step_time; }
+};
+
+// ============================================================================
+// 18. SUPPLIER MODEL
+// ============================================================================
+
+// Supplier: Represents a supplier in a simulation.
+// Purpose:
+//  - Simulates the supply of products at specific intervals.
+//  - Generates random supply requests periodically based on the defined
+//  intervals.
+// Usage:
+//  Supplier supplier(minInterval, maxInterval, numProducts, rng);
+//  int suppliedProduct = supplier.step(timeStep);
+//  supplier.reset();
+class Supplier {
+private:
+  double nextSupplyTime;
+  double minInterval;
+  double maxInterval;
+  int numProducts;
+  RandomGenerator &rng;
+
+public:
+  Supplier(double V, double Q, int N, RandomGenerator &generator)
+      : minInterval(V), maxInterval(Q), numProducts(N), rng(generator) {
+    nextSupplyTime = rng.uniform(V, Q);
+  }
+
+  int step(double dt) {
+    nextSupplyTime -= dt;
+    if (nextSupplyTime <= 0) {
+      nextSupplyTime = rng.uniform(minInterval, maxInterval);
+      return rng.uniformInt(1, numProducts);
+    }
+    return 0;
+  }
+
+  void reset() { nextSupplyTime = rng.uniform(minInterval, maxInterval); }
+};
+
+// Server di inventario con messaggi (customer/server network-style)
+class InventoryServerProcess : public DiscreteEventProcess {
+public:
+  InventoryServerProcess(int pid, int numItems, int initialStockPerItem,
+                         double serviceTime, MessageBus &bus,
+                         RandomGenerator &rng)
+      : pid_(pid), serviceTime_(serviceTime), bus_(bus), rng_(rng),
+        nextEventTime_(0.0),
+        storage_(static_cast<std::size_t>(numItems), initialStockPerItem),
+        totalRequests_(0), missedRequests_(0) {}
+
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + serviceTime_;
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // processa TUTTI i messaggi arrivati a questo server
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      totalRequests_++;
+
+      // sicurezza sugli indici prodotto
+      if (m.item < 0 || static_cast<std::size_t>(m.item) >= storage_.size()) {
+        continue; // scarta richieste invalide
+      }
+
+      double servedQty = 0.0;
+      int &stock = storage_[static_cast<std::size_t>(m.item)];
+
+      if (stock >= static_cast<int>(m.quantity)) {
+        // richiesta soddisfatta
+        stock -= static_cast<int>(m.quantity);
+        servedQty = m.quantity;
+      } else {
+        // non abbastanza stock
+        servedQty = static_cast<double>(stock);
+        missedRequests_++;
+        stock = 0;
+      }
+
+      // risposta al cliente
+      Message reply;
+      reply.time = currentTime;
+      reply.sender = pid_;
+      reply.receiver = m.sender; // rimanda al mittente
+      reply.item = m.item;
+      reply.quantity = servedQty;
+
+      bus_.procToNet(pid_).push(reply);
+
+      // eventuale logica di refill: esempio semplice
+      if (stock == 0) {
+        int refill = rng_.uniformInt(1, 10); // batch di rifornimento random
+        stock += refill;
+      }
+    }
+
+    nextEventTime_ = currentTime + serviceTime_;
+  }
+
+  const std::vector<int> &storage() const { return storage_; }
+
+  int totalRequests() const { return totalRequests_; }
+  int missedRequests() const { return missedRequests_; }
+
+private:
+  int pid_;
+  double serviceTime_;
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+  std::vector<int> storage_;
+
+  int totalRequests_;
+  int missedRequests_;
+};
+
+// ============================================================================
+// 19. INVENTORY CUSTOMER PROCESS (DES-compatible)
+// ============================================================================
+//
+// InventoryCustomerProcess:
+//  - Processo a eventi discreti che rappresenta un cliente.
+//  - Invia richieste al server tramite MessageBus (procToNet -> NetworkRouter).
+//  - Legge le risposte dal canale netToProc.
+//  - Statistiche: quante richieste ha mandato e quante risposte ha ricevuto.
+//
+class InventoryCustomerProcess : public DiscreteEventProcess {
+public:
+  // pid              : id di questo processo (indice nei canali del MessageBus)
+  // serverPid        : pid del server a cui mandare le richieste
+  // numItems         : numero di prodotti gestiti (item in [0, numItems-1])
+  // minInterval/maxInterval : intervallo di tempo tra una richiesta e la
+  // successiva
+  InventoryCustomerProcess(int pid, int serverPid, int numItems,
+                           double minInterval, double maxInterval,
+                           MessageBus &bus, RandomGenerator &rng)
+      : pid_(pid), serverPid_(serverPid), numItems_(numItems),
+        minInterval_(minInterval), maxInterval_(maxInterval), bus_(bus),
+        rng_(rng), nextEventTime_(0.0), issuedRequests_(0), receivedReplies_(0),
+        totalRequestedQty_(0.0), totalServedQty_(0.0) {}
+
+  // inizializza il prossimo evento (prima richiesta)
+  void initialize(double startTime) override {
+    nextEventTime_ = startTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  double nextEventTime() const override { return nextEventTime_; }
+
+  void handleEvent(double currentTime) override {
+    if (currentTime < nextEventTime_) {
+      return;
+    }
+
+    // 1) genera una nuova richiesta al server
+    const int item = rng_.uniformInt(
+        0, numItems_ - 1); // coerente con InventoryServerProcess
+    const int qty = rng_.uniformInt(1, 3); // quantità richiesta (1..3)
+
+    Message req;
+    req.time = currentTime;
+    req.sender = pid_;
+    req.receiver = serverPid_;
+    req.item = item;
+    req.quantity = static_cast<double>(qty);
+
+    bus_.procToNet(pid_).push(req);
+    issuedRequests_++;
+    totalRequestedQty_ += req.quantity;
+
+    // 2) processa tutte le risposte arrivate su questo cliente
+    auto &inbox = bus_.netToProc(pid_);
+    while (!inbox.empty()) {
+      Message m = inbox.front();
+      inbox.pop();
+
+      // opzionale: possiamo filtrare solo messaggi dal serverPid_
+      // if (m.sender != serverPid_) continue;
+
+      receivedReplies_++;
+      totalServedQty_ += m.quantity;
+    }
+
+    // 3) pianifica la prossima richiesta
+    nextEventTime_ = currentTime + rng_.uniform(minInterval_, maxInterval_);
+  }
+
+  // --- metriche accessibili dall’esterno ---
+
+  int pid() const { return pid_; }
+  int serverPid() const { return serverPid_; }
+
+  int issuedRequests() const { return issuedRequests_; }
+  int receivedReplies() const { return receivedReplies_; }
+
+  double totalRequestedQty() const { return totalRequestedQty_; }
+  double totalServedQty() const { return totalServedQty_; }
+
+  // fill-rate lato customer
+  double serviceLevel() const {
+    if (totalRequestedQty_ <= 0.0)
+      return 1.0;
+    return totalServedQty_ / totalRequestedQty_;
+  }
+
+private:
+  int pid_;
+  int serverPid_;
+  int numItems_;
+  double minInterval_;
+  double maxInterval_;
+
+  MessageBus &bus_;
+  RandomGenerator &rng_;
+
+  double nextEventTime_;
+
+  int issuedRequests_;
+  int receivedReplies_;
+  double totalRequestedQty_;
+  double totalServedQty_;
+};
+
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/5/include/Queue.hpp b/exams/AxelRubini/2026-01-14/5/include/Queue.hpp
new file mode 100644
index 0000000..0c12ce8
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/include/Queue.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <stdexcept>
+
+namespace SELib {
+// ============================================================================
+// 9. FIFO QUEUE
+// ============================================================================
+
+// FIFOQueue: Implements a first-in-first-out (FIFO) queue with a fixed maximum
+// size. Purpose:
+//  - Enqueue and dequeue items in FIFO order.
+//  - Track statistics such as total items enqueued and dequeued.
+//  - Support dynamic size constraints.
+// Usage:
+//  FIFOQueue<int> queue(10);
+//  queue.enqueue(5);
+//  int item;
+//  if (queue.dequeue(item)) {
+//    // Process item.
+//  }
+template <typename T> class FIFOQueue {
+private:
+  std::queue<T> queue;
+  size_t maxSize;
+  size_t totalEnqueued;
+  size_t totalDequeued;
+
+public:
+  FIFOQueue(size_t max = SIZE_MAX)
+      : maxSize(max), totalEnqueued(0), totalDequeued(0) {}
+
+  bool enqueue(const T &item) {
+    if (queue.size() >= maxSize)
+      return false;
+    queue.push(item);
+    totalEnqueued++;
+    return true;
+  }
+
+  bool dequeue(T &item) {
+    if (queue.empty())
+      return false;
+    item = queue.front();
+    queue.pop();
+    totalDequeued++;
+    return true;
+  }
+
+  bool isEmpty() const { return queue.empty(); }
+  bool isFull() const { return queue.size() >= maxSize; }
+  size_t size() const { return queue.size(); }
+  size_t getTotalEnqueued() const { return totalEnqueued; }
+  size_t getTotalDequeued() const { return totalDequeued; }
+  std::queue<T> getQueue() const { return queue; }
+  T getFirst() const {
+    if (queue.empty())
+      throw std::runtime_error("Queue is empty");
+    return queue.front();
+  }
+
+  void clear() {
+    while (!queue.empty())
+      queue.pop();
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/5/include/Random.hpp b/exams/AxelRubini/2026-01-14/5/include/Random.hpp
new file mode 100644
index 0000000..52356f9
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/include/Random.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cmath>   // std::isfinite
+#include <numeric> // std::accumulate
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace SELib {
+
+class RandomGenerator {
+private:
+  std::mt19937 gen;
+
+public:
+  explicit RandomGenerator(unsigned seed = std::random_device{}())
+      : gen(seed) {}
+
+  double uniform(double min, double max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_real_distribution<double> dis(lo, high);
+    return dis(gen);
+  }
+
+  int uniformInt(int min, int max) {
+    auto lo = std::min(min, max);
+    auto high = std::max(min, max);
+    std::uniform_int_distribution<int> dis(lo, high);
+    return dis(gen);
+  }
+
+  double gaussian(double mean, double stddev) {
+    if (stddev < 0.0) {
+      throw std::invalid_argument("gaussian: stddev must be >= 0");
+    }
+    std::normal_distribution<double> dis(mean, stddev);
+    return dis(gen);
+  }
+
+  bool bernoulli(double p) {
+    if (p < 0.0 || p > 1.0 || !std::isfinite(p)) {
+      throw std::invalid_argument("bernoulli: p must be in [0,1]");
+    }
+    std::bernoulli_distribution dis(p);
+    return dis(gen);
+  }
+
+  int discrete(const std::vector<double> &probabilities) {
+    if (probabilities.empty()) {
+      throw std::invalid_argument("discrete: empty probability vector");
+    }
+
+    for (double w : probabilities) {
+      if (w < 0.0 || !std::isfinite(w)) {
+        throw std::invalid_argument(
+            "discrete: weights must be non-negative and finite");
+      }
+    }
+
+    double sum =
+        std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
+    if (sum <= 0.0) {
+      throw std::invalid_argument("discrete: sum of weights must be > 0");
+    }
+
+    std::discrete_distribution<int> dis(probabilities.begin(),
+                                        probabilities.end());
+    return dis(gen);
+  }
+
+  void setSeed(unsigned seed) { gen.seed(seed); }
+
+  // (opzionale) accesso al motore se ti serve per altre distribuzioni
+  std::mt19937 &engine() { return gen; }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/5/include/Stat.hpp b/exams/AxelRubini/2026-01-14/5/include/Stat.hpp
new file mode 100644
index 0000000..27b4656
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/include/Stat.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace SELib {
+// ============================================================================
+// 2. STATISTICS
+// ============================================================================
+
+// Statistics: A utility class for managing and analyzing numerical data
+// samples. Purpose:
+//  - Compute statistical metrics such as mean and standard deviation.
+//  - Estimate probabilities of custom conditions.
+//  - Check convergence of data over iterations.
+// Usage:
+//  Statistics stats;
+//  stats.addSample(5.0);
+//  double meanValue = stats.mean();
+class Statistics {
+private:
+  std::vector<double> samples;
+
+public:
+  void addSample(double value) { samples.push_back(value); }
+
+  void clear() { samples.clear(); }
+
+  double mean() const {
+    if (samples.empty())
+      return 0.0;
+    double sum = 0.0;
+    for (double s : samples)
+      sum += s;
+    return sum / samples.size();
+  }
+
+  double stddev() const {
+    if (samples.size() < 2)
+      return 0.0;
+    double m = mean();
+    double variance = 0.0;
+    for (double s : samples) {
+      variance += (s - m) * (s - m);
+    }
+    return std::sqrt(variance / (samples.size() - 1));
+  }
+
+  double probability(std::function<bool(double)> condition) const {
+    if (samples.empty())
+      return 0.0;
+    int count = 0;
+    for (double s : samples) {
+      if (condition(s))
+        count++;
+    }
+    return static_cast<double>(count) / samples.size();
+  }
+
+  size_t size() const { return samples.size(); }
+  const std::vector<double> &getSamples() const { return samples; }
+
+  bool hasConverged(double tolerance = 0.1) const {
+    if (samples.size() < 30)
+      return false;
+    double m = mean();
+    double sd = stddev();
+    return sd <= tolerance * std::abs(m);
+  }
+};
+} // namespace SELib
diff --git a/exams/AxelRubini/2026-01-14/5/main b/exams/AxelRubini/2026-01-14/5/main
new file mode 100755
index 0000000000000000000000000000000000000000..67513e5b7b9b18b1f218d043d43ee030786fa847
GIT binary patch
literal 81712
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%0DyxA0YpK_-gY1Ru}mvGf@7?1b+D^
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

literal 0
HcmV?d00001

diff --git a/exams/AxelRubini/2026-01-14/5/main.cpp b/exams/AxelRubini/2026-01-14/5/main.cpp
new file mode 100644
index 0000000..98fb26d
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/main.cpp
@@ -0,0 +1,110 @@
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <iomanip>
+#include "include/DES.hpp"
+#include "include/IO.hpp"
+#include "include/Random.hpp"
+#include "include/Stat.hpp"
+#include "include/Decision.hpp"
+
+namespace SELib {
+
+class CustomerProcess : public DiscreteEventProcess {
+public:
+    CustomerProcess(int pid, int S, int P, int Q, double A, double B, MessageBus &bus, RandomGenerator &rng)
+        : pid_(pid), S_(S), P_(P), Q_(Q), A_(A), B_(B), bus_(bus), rng_(rng) {}
+    void initialize(double startTime) override { nextTime_ = startTime + rng_.uniform(A_, B_); }
+    double nextEventTime() const override { return nextTime_; }
+    void handleEvent(double currentTime) override {
+        Message m; m.time = currentTime; m.sender = pid_; m.receiver = 100 + rng_.uniformInt(0, S_ - 1);
+        m.item = rng_.uniformInt(1, P_); m.quantity = (double)rng_.uniformInt(1, Q_);
+        bus_.procToNet(pid_).push(m);
+        nextTime_ = currentTime + rng_.uniform(A_, B_);
+    }
+private:
+    int pid_, S_, P_, Q_; double A_, B_, nextTime_; MessageBus &bus_; RandomGenerator &rng_;
+};
+
+class SupplierProcess : public DiscreteEventProcess {
+public:
+    SupplierProcess(int pid, int S, int P, int Q, double V, double W, MessageBus &bus, RandomGenerator &rng)
+        : pid_(pid), S_(S), P_(P), Q_(Q), V_(V), W_(W), bus_(bus), rng_(rng) {}
+    void initialize(double startTime) override { nextTime_ = startTime + rng_.uniform(V_, W_); }
+    double nextEventTime() const override { return nextTime_; }
+    void handleEvent(double currentTime) override {
+        Message m; m.time = currentTime; m.sender = pid_; m.receiver = 100 + rng_.uniformInt(0, S_ - 1);
+        m.item = -rng_.uniformInt(1, P_); m.quantity = (double)rng_.uniformInt(0, Q_);
+        bus_.procToNet(pid_).push(m);
+        nextTime_ = currentTime + rng_.uniform(V_, W_);
+    }
+private:
+    int pid_, S_, P_, Q_; double V_, W_, nextTime_; MessageBus &bus_; RandomGenerator &rng_;
+};
+
+class ServerProcess : public DiscreteEventProcess {
+public:
+    ServerProcess(int pid, int C, int F, int P, int Q, MessageBus &bus, RandomGenerator &rng, long long &ms)
+        : pid_(pid), C_(C), F_(F), P_(P), Q_(Q), bus_(bus), rng_(rng), ms_(ms) {
+        inv_.assign(P + 1, 0);
+    }
+    void initialize(double startTime) override {
+        for(int i=1; i<=P_; ++i) inv_[i] = rng_.uniformInt(0, Q_);
+        nextTime_ = startTime + 0.1;
+    }
+    double nextEventTime() const override { return nextTime_; }
+    void handleEvent(double currentTime) override {
+        auto &inbox = bus_.netToProc(pid_);
+        while (!inbox.empty()) {
+            Message m = inbox.front(); inbox.pop();
+            bool isSupply = (m.item < 0);
+            if (isSupply) { inv_[-m.item] += (int)m.quantity; }
+            else {
+                int req = (int)m.quantity;
+                if (inv_[m.item] < req) ms_++;
+                int prov = std::min(req, inv_[m.item]); inv_[m.item] -= prov;
+            }
+        }
+        nextTime_ = currentTime + 0.1;
+    }
+private:
+    int pid_, C_, F_, P_, Q_; MessageBus &bus_; RandomGenerator &rng_; long long &ms_;
+    double nextTime_; std::vector<int> inv_;
+};
+
+struct Result { double R, V, W, J; };
+
+Result runMsims(double V_val, double H, int M, int C, int S, int P, int Q, int F_suppliers, double A, double B, RandomGenerator &rng, double a, double b) {
+    Statistics s; double W_val = V_val + 5.0;
+    for (int m = 0; m < M; ++m) {
+        MessageBus bus(200); DiscreteEventSystem system; long long ms = 0;
+        for(int i=0; i<C; ++i) system.emplaceProcess<CustomerProcess>(i, S, P, Q, A, B, bus, rng);
+        for(int i=0; i<F_suppliers; ++i) system.emplaceProcess<SupplierProcess>(C+i, S, P, Q, V_val, W_val, bus, rng);
+        for(int i=0; i<S; ++i) system.emplaceProcess<ServerProcess>(100+i, C, F_suppliers, P, Q, bus, rng, ms);
+        system.emplaceProcess<NetworkRouter>(bus, rng, 0.01);
+        DiscreteEventSimulator sim(system); sim.run(H);
+        s.addSample((double)ms / H);
+    }
+    double R_mean = s.mean(); return {R_mean, V_val, W_val, a * V_val + b * R_mean};
+}
+
+}
+
+int main() {
+    SELib::RandomGenerator rng(0); SELib::ParameterParser parser; if (!parser.parseFile("parameters.txt")) return 1;
+    double H = parser.getDouble("H");
+    int M = parser.getInt("M"), C = parser.getInt("C"), S = parser.getInt("S"), P = parser.getInt("P"), Q = parser.getInt("Q"), F_suppliers = parser.getInt("F"), G = parser.getInt("G");
+    double A = parser.getDouble("A"), B = parser.getDouble("B"), a_cost = parser.getDouble("a"), b_cost = parser.getDouble("b");
+
+    SELib::Result bestRes = {0, 0, 0, 1e18};
+    for (int i = 0; i < G; ++i) {
+        double V_cand = rng.uniform(0.1, 10.0);
+        auto res = SELib::runMsims(V_cand, H, M, C, S, P, Q, F_suppliers, A, B, rng, a_cost, b_cost);
+        if (res.J < bestRes.J) bestRes = res;
+    }
+    std::ofstream outFile("results.txt"); outFile << "2026-01-14-Axel-Rubini-2158099" << std::endl;
+    outFile << "R " << bestRes.R << std::endl; outFile << "V " << bestRes.V << std::endl; outFile << "W " << bestRes.W << std::endl; outFile << "J " << bestRes.J << std::endl;
+    return 0;
+}
diff --git a/exams/AxelRubini/2026-01-14/5/parameters.txt b/exams/AxelRubini/2026-01-14/5/parameters.txt
new file mode 100644
index 0000000..0eaf7e4
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/parameters.txt
@@ -0,0 +1,17 @@
+T 1.0
+M 10
+H 1000
+C 30
+S 1
+F 10
+Q 1
+A 1.5
+B 2.5
+V 10.1
+W 20.1
+P 1
+G 10
+a -0.9
+b 0.1
+
+
diff --git a/exams/AxelRubini/2026-01-14/5/results.txt b/exams/AxelRubini/2026-01-14/5/results.txt
new file mode 100644
index 0000000..a4d7fe5
--- /dev/null
+++ b/exams/AxelRubini/2026-01-14/5/results.txt
@@ -0,0 +1,5 @@
+2026-01-14-Axel-Rubini-2158099
+R 14.4923
+V 9.9602
+W 14.9602
+J -7.51495