Skip to content

GitLab

Commit 434ccf94 authored by Cyril L'Orphelin's avatar Cyril L'Orphelin
Browse files

Add activation CI/CD

parent 0c8ff996
Hide whitespace changes
Inline Side-by-side
Showing with 29 additions and 265 deletions
TP2/ReadMe.md
View file @ 434ccf94
......@@ -135,4 +135,9 @@ nothing to commit, working tree clean
- Reproduisez le même problème de conflit
- MAIS faites la tentative de merge dans Gitlab
- Résolvez le problème dans l'interface de Gitlab
- Supprimez les branches automatiquement dans Gitlab après le merge
\ No newline at end of file
- Supprimez les branches automatiquement dans Gitlab après le merge
### Bonus : Astuces d'utilisation
- Placez vous dans le répertoire TP2
-
\ No newline at end of file
TP4/ReadMe.md
View file @ 434ccf94
......@@ -57,267 +57,25 @@ $ coverage report -m --omit=tri_test.py
<details>
<summary>Solution</summary>
<pre><code># -*- coding: utf-8 -*-
"""
Comparaison des performances de plusieurs algorithmes de tri écrit en Python
\n tri par selection
\n tri par selection récursif
\n tri par insertion
\n tri fusion
\n tri bulle
\n tri rapide
:author: cyril
:copyright: cnrs
"""
import random
import timeit
def tri_selection(tab, longueur):
"""
Tri par sélection \n
On détermine la position du plus petit élément, on le met en première
position et on itère le procédé sur le tableau restant. \n
Complexité en 0(lgn2) dans tous les cas.
:param tab: tableau à trier
:type tab: array
:param longueur: taille du tableau
:return: tableau trié
:rtype: array
"""
if longueur < 2:
# Moins de 2 éléments : pas besoin de trier
return tab
for index in range(longueur - 1):
# On suppose que le min est en premier
mini = tab[index]
imin = index
for j in range(index + 1, longueur):
if tab[j] < mini:
# On met à jour le mini
mini = tab[j]
imin = j
if imin != index:
# On pertmute pour mettre le min en premier
tab[imin] = tab[index]
tab[index] = mini
return tab
def tri_recursif(tab, longueur):
"""
Tri par sélection récursif\n
On détermine la position du plus grand élément et on le met en dernière
position. On réappelle alors la fonction tri_recursif sur le sous tableau
composé des n-1 premiers éléments de t.\n
Complexité en O(n**2) dans tous les cas.
:param tab: tableau à trier
:type tab: array
:param longueur: taille du tableau
:return: tableau trié
:rtype: array
"""
if longueur < 2:
# Moins de 2 éléments : pas besoin de trier
return tab
# On suppose que le max est en dernier
maxi = tab[longueur - 1]
imax = longueur - 1
for index in range(longueur - 2):
if tab[index] > maxi:
# On met à jour le max
maxi = tab[index]
imax = index
if imax != longueur - 1:
# On permute pour mettre le max en dernier
tab[imax] = tab[longueur - 1]
tab[longueur - 1] = maxi
# Appel de tri_recursif sur t de taille n-1 pour trier le reste du tableau
tab = tri_recursif(tab, longueur - 1)
return tab
def tri_insertion(tab, longueur):
"""
Tri par insertion\n
On ordonne les deux premiers éléments.\n
On insère le 3ème de manière à ce que les 3 soient ordonnés.\n
On insère le i-ème de manière à ce que les i éléments soient ordonnées.\n
La complèxité est en O(n**2) dans le pire des cas.\n
:param tab: tableau à trier
:type tab: array
:param longueur: taille du tableau
:return: tableau trié
:rtype: array
"""
if longueur < 2:
# Moins de 2 éléments : pas besoin de trier
return tab
for index in range(2, longueur):
item = tab[index] # un élément de la t
j = index
# tant qu'on n'a pas atteint le début ou un élément plus petit
while j > 0 and tab[j - 1] > item:
tab[j] = tab[j - 1] # on décale l'élément trouvé vers la droite
j = j - 1
tab[j] = item # on insere item a sa place
return tab
def tri_fusion(tab, longueur):
"""
Tri fusion\n
On découpe le tableau à trier en deux sous-tableaux de taille n/2.
On trie alors les deux sous-tableaux récursivement, ou on ne fait rien
s'ils sont de taille 1.\n
On reconstitue le tableau trié initial en fusionnant les deux sous-tableaux
triés.\n
La complexité est en O(n*log(n)) dans le pire des cas.\n
:param tab: tableau à trier
:type tab: array
:param longueur: taille du tableau
:return: tableau trié
:rtype: array
"""
def vidage(ta, pa, na, tab, pos):
"""
Copie ta de taille na à partir de la position pa dans t à partir de p
:param ta: tableau à copier
:param pa: position à partir de laquelle copier
:param na: taille de ta
:param tab: tableau de destination
:param p: position à partir de laquelle coller
:return:
"""
for index in range(pa, na):
tab[pos] = ta[index]
pos += 1
return tab
if longueur < 2:
# Moins de 2 éléments : pas besoin de trier
return tab
# Cas général : on découpe le tableau en 2 partie que l'on trie
pos = longueur // 2
tab1 = tab[:pos]
lgn1 = len(tab1)
tab1 = tri_fusion(tab1, lgn1)
tab2 = tab[pos:]
lgn2 = len(tab2)
tab2 = tri_fusion(tab2, lgn2)
# Fusion des deux parties
pos1, pos2, pos = 0, 0, 0 # position dans tab1, tab2 et t
while pos1 < lgn1 and pos2 < lgn2:
if tab1[pos1] < tab2[pos2]:
# On met tab1[pos1] dans t
tab[pos] = tab1[pos1]
pos1 += 1
else:
# On met tab2[pos2] dans t
tab[pos] = tab2[pos2]
pos2 += 1
pos += 1
if pos1 == len(tab1):
vidage(tab2, pos2, len(tab2), tab, pos)
else:
vidage(tab1, pos1, len(tab1), tab, pos)
return tab
def tri_bulle(tab, longueur):
"""
Tri bulle\n
On compare les couples d'éléments successifs pour placer systématiquement
le plus grand après le plus petit. Un parcours complet du tableau selon
ce processus nous assure que le plus grand élément est en dernière
position. \nOn réitère alors le processus sur le sous tableau restant.\n
Complexité en O(n**2).
:param tab: tableau à trier
:type tab: array
:param longueur: taille du tableau
:return: tableau trié
:rtype: array
"""
if longueur < 2:
# Moins de 2 éléments : pas besoin de trier
return tab
for index in range(longueur - 1):
for j in range(longueur - 1 - index):
if tab[j] > tab[j + 1]:
# On permute
temp = tab[j]
tab[j] = tab[j + 1]
tab[j + 1] = temp
return tab
def tri_rapide(tab, longueur):
"""
Tri rapide\n
On choisit un élément du tableau au hasard qui sera 'pivot' et on permute
tous les éléments de manière à placer à gauche du pivot les éléments qui
lui sont inférieurs, et à droite ceux qui lui sont supérieurs.\n
On trie alors de la meme manière les deux moitiés de part et d'autre du
pivot.\n
Complexité en O(nlog(n)).
:param tab: tableau à trier
:type tab: array
:param longueur: taille du tableau
:return: tableau trié
:rtype: array
"""
def tri_rapide_rec(tab, i, j):
if i >= j:
# Pas besoin de trier
return tab
pos = i
# On place les éléments plus petits que le pivot (tab[j-1]) au début
for k in range(i, j - 1):
if tab[k] <= tab[j - 1]:
tab[k], tab[pos] = tab[pos], tab[k]
pos += 1
# On remet le pivot après les éléments plus petits
tab[j - 1], tab[pos] = tab[pos], tab[j - 1]
# On trie les deux parties
tri_rapide_rec(tab, i, pos - 1)
tri_rapide_rec(tab, pos + 1, j - 1)
return tab
if longueur < 2:
# Moins de 2 éléments : pas besoin de trier
return tab
tab = tri_rapide_rec(tab, 0, longueur)
return tab
if __name__ == '__main__':
import sys
sys.setrecursionlimit(100000)
TAB_LONGUEURS = [10, 1000, 10000]
TAB_METHODS = {0: tri_selection, 1: tri_recursif, 2: tri_insertion, 3: tri_fusion, 4: tri_bulle, 5: tri_rapide}
for longueurT in TAB_LONGUEURS:
t0 = random.sample(range(1, 100000), longueurT)
print("############# LONGUEUR :" + str(longueurT) + " ###########")
for idx in range(6):
start = timeit.default_timer()
TAB_METHODS[idx](t0, longueurT)
stop = timeit.default_timer()
execution_time = stop - start
print("{:20} => {:.02E}".format(TAB_METHODS[idx].__name__ , execution_time))</code></pre>
<pre><code>
if __name__ == '__main__':
import sys
sys.setrecursionlimit(100000)
TAB_LONGUEURS = [10, 1000, 10000]
TAB_METHODS = {0: tri_selection, 1: tri_recursif, 2: tri_insertion, 3: tri_fusion, 4: tri_bulle, 5: tri_rapide}
for longueurT in TAB_LONGUEURS:
t0 = random.sample(range(1, 100000), longueurT)
print("############# LONGUEUR :" + str(longueurT) + " ###########")
for idx in range(6):
start = timeit.default_timer()
TAB_METHODS[idx](t0, longueurT)
stop = timeit.default_timer()
execution_time = stop - start
print("{:20} => {:.02E}".format(TAB_METHODS[idx].__name__ , execution_time))</code></pre>
</details>
----
......@@ -338,11 +96,12 @@ Si vous voulez installer le client pour tester du code local à votre machine, s
1. Placez vous sur le répertoire de votre choix sur le Notebook ou localement
2. Rechercher dans votre projet perso Gitlab dans les variables de CI/CD: le token et le nom du projet pour Sonar
3. Passez une commande similaire à celle -ci en pointant sur le code de votre choix
3. Passez une commande similaire à celle -ci en pointant sur le code de votre choix
<code>sonar-scanner \
-Dsonar.projectKey=votre_projet \
-Dsonar.sources=. \
-Dsonar.sources=tri.py \
-Dsonar.tests=tri_test.py \
-Dsonar.host.url=https://sonarqube.cc.in2p3.fr \
-Dsonar.login=votre_token
</code>
......
TP5/ReadMe.md
View file @ 434ccf94
......@@ -9,7 +9,7 @@
- Le TP est réalisable entièrement dans Gitlab avec l'aide de l'éditeur de pipeline
- Vous allez vous placer sur votre projet personnel anf
- Vous allez créer une nouvelle branche tp5
- Vous allez vérifier dans les préférences générales du projet si la CI/CD est activée, activez la si nécessaire
- Vous allez vérifier dans les préférences générales du projet si la CI/CD est activée, activez la si nécessaire : <code>Settings > General > Visibility, project features, permissions</code>
- A partir de maintenant, vous allez simplement éditer et commiter le manifeste .gitlab-ci.yml
- Vous avez des liens pour vous aider sur chaque mot clé qui pointent sur la documentation Gitlab
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment