# Compte rendu – TD Complexité cyclomatique (R5.A.04)

## Partie 1 – Graphes de flot de contrôle

Pour chaque fonction, on construit le graphe de flot de contrôle (un nœud = un bloc sans branchement, une décision = un nœud à deux sorties, un seul nœud de sortie), puis on applique :

**M = E − N + 2P** (E = arêtes, N = nœuds, P = 1 pour une fonction)

On vérifie ensuite le résultat avec la règle pratique **M = décisions + 1**.

### C2 – `moyenne` (C)

![Graphe C2](Graphe/C2.jpg)

| Nœud | Contenu |
|---|---|
| 1 | `somme = 0 ; i = 0` |
| 2 | décision `i < n` |
| 3 | `somme += t[i]` |
| 4 | `i++` (arête de retour vers 2) |
| 5 | décision `n > 0` (ternaire) |
| 6 | `somme / n` |
| 7 | `0` |
| 8 | sortie (`return`) |

- N = 8, E = 9, P = 1
- **M = 9 − 8 + 2 × 1 = 3**
- Vérification : 1 `for` + 1 ternaire `?:` + 1 = 3

### J2 – `estDisponible` (Java)

![Graphe J2](Graphe/J2.png)

La méthode ne contient aucun `if`, mais les `&&` sont évalués paresseusement : chaque opérande est une décision (si `livre.emprunte` est vrai, on sort directement sans évaluer la suite).

| Nœud | Contenu |
|---|---|
| 1 | décision `!livre.emprunte` |
| 2 | décision `!livre.reserve` |
| 3 | décision `!livre.abime` |
| 4 | sortie (`return`) |

- N = 4, E = 5, P = 1
- **M = 5 − 4 + 2 × 1 = 3**
- Vérification : 2 opérateurs `&&` + 1 = 3

### P2 – `signe` (Python)

![Graphe P2](Graphe/P2.jpg)

| Nœud | Contenu |
|---|---|
| 1 | décision `x > 0` |
| 2 | `return 1` |
| 3 | décision `x < 0` (`elif`) |
| 4 | `return -1` |
| 5 | `return 0` |
| 6 | sortie |

- N = 6, E = 7, P = 1
- **M = 7 − 6 + 2 × 1 = 3**
- Vérification : 1 `if` + 1 `elif` + 1 = 3

### P3 – `notes_valides` (Python)

![Graphe P3](Graphe/P3.jpg)

La compréhension de liste cache une boucle et un filtre : elle se lit comme un `for` contenant un `if`.

| Nœud | Contenu |
|---|---|
| 1 | initialisation de la liste résultat |
| 2 | décision : reste-t-il un élément `n` dans `notes` ? |
| 3 | décision `0 <= n <= 20` |
| 4 | ajout de `n` au résultat (retour vers 2) |
| 5 | sortie (`return`) |

- N = 5, E = 6, P = 1
- **M = 6 − 5 + 2 × 1 = 3**
- Vérification : 1 `for` + 1 `if` (dans la compréhension) + 1 = 3

> Remarque : `0 <= n <= 20` est une comparaison chaînée, équivalente à `0 <= n and n <= 20`. Si on compte ce `and` implicite comme une décision, on obtient M = 4. Nous l'avons compté comme une seule condition, comme le font la plupart des outils (aucun opérateur `and` n'apparaît dans le code).

### Récapitulatif

| Fonction | N | E | M | Classe |
|---|---|---|---|---|
| C2 `moyenne` | 8 | 9 | 3 | Simple |
| J2 `estDisponible` | 4 | 5 | 3 | Simple |
| P2 `signe` | 6 | 7 | 3 | Simple |
| P3 `notes_valides` | 5 | 6 | 3 | Simple |