# Exercice 2

Pour un tableau de taille 10 000 :

racineCarreeTab() est appelé qu'une seule fois et prend près de 0% du temps d'exécution total.
Elle est appelé par le main et fait appel à la fonction racineCarree() 10 000 fois et cette même fonction a 10.63s d'exécution.

On peut donc conclure que pour optimiser ce temps, on devra soit limité le nombre d'appel à la fonction racineCarree() ou alors optimiser cette fonction.

```
index % time    self  children    called     name
        10.63    0.00   10000/10000       racineCarreeTab [2]
[1]    100.0   10.63    0.00   10000         racineCarree [1]
-----------------------------------------------
            0.00   10.63       1/1           main [3]
[2]    100.0    0.00   10.63       1         racineCarreeTab [2]
      10.63    0.00   10000/10000       racineCarree [1]
-----------------------------------------------
                                            <spontaneous>
[3]    100.0    0.00   10.63                 main [3]
       0.00   10.63       1/1           racineCarreeTab [2]
-----------------------------------------------
```



## Complexité cyclomatique
    racineCarree()
La complexité cyclomatique de racineCarree() est 5.

    racineCarreeTab()
La complexité cyclomatique de racineCarreeTab() est 2.

## Complexité algorithmique

    racineCarree()
La complexité algorithmique de racineCarree() est 

    racineCarreTab()

La complexité algorithmique de racineCarreeTab() est


# Exercice 4


```
index % time    self  children    called     name
                0.00    0.00       6/19          sommeRacines [4]
                0.00    0.00      13/19          TriSpecial [2]
[1]      0.0    0.00    0.00      19         racineCarree [1]
-----------------------------------------------
                0.00    0.00       2/2           main [8]
[2]      0.0    0.00    0.00       2         TriSpecial [2]
                0.00    0.00      13/19          racineCarree [1]
                0.00    0.00       1/1           somme [3]
                0.00    0.00       1/1           sommeRacines [4]
-----------------------------------------------
                0.00    0.00       1/1           TriSpecial [2]
[3]      0.0    0.00    0.00       1         somme [3]
-----------------------------------------------
                0.00    0.00       1/1           TriSpecial [2]
[4]      0.0    0.00    0.00       1         sommeRacines [4]
                0.00    0.00       6/19          racineCarree [1]
-----------------------------------------------
```

## Complexité cyclomatique

    TriSpecial()
La complexité cyclomatique de TriSpepcial() est de 5.

## Complexité algorithmique
    TriSpecial()
La complexité algorithmique de TriSpecial() est