Upload New File

src/tests_swap.py

+import itertools
+
+#Fonction outil pour calculer la parent distance.
+#max_j(seq, i) trouve le plus grand entier j tq S[j] < S[i]
+#et retourne j, ou retourne 0 si un tel j n'existe pas.
+def max_j(seq, i):
+    j = 0
+    for k in range(0, i):
+        if seq[k] < seq[i]:
+            j = k + 1 #+1 pour la numérotation
+    return j
+
+#Parent-distance classique, lue de la gauche vers la droite.
+def pdd(seq):
+    res = []
+    for i in range(len(seq)):
+        j = max_j(seq, i)
+        if j != 0:
+            res.append(i + 1 - j) #+1 pour la numérotation
+        else:
+            res.append(0)
+    return res
+
+#Parent-distance de la droite vers la gauche, version paresseuse
+#Il serait peut-être bon de la redéfinir comme pdd.
+def pdg(seq):
+    s = seq.copy()
+    list.reverse(s)
+    res = pdd(s)
+    list.reverse(res)
+    return res
+
+#first_diff gauche et droite identifient la première position
+#où les parent-distances diffèrent afin de mettre en évidence
+#les deux indices sur lesquels le swap s'est possiblement produit.
+#Chaque fonction renvoie l'indice de la première position qui diffère
+#ou -1 si une telle position n'existe pas
+def first_diff_d(pdd1, pdd2):
+    for index, value in enumerate(zip(pdd1, pdd2)):
+        if value[0] != value[1]:
+            return index
+    return -1
+
+def first_diff_g(pdg1, pdg2):
+    for index, value in reversed(list(enumerate(zip(pdg1, pdg2)))):
+        if value[0] != value[1]:
+            return index
+    return -1
+
+
+#Vérifie les conditions nécessaires (mais pas suffisantes)
+#sur les éléments des parent-distances
+#Voir pour factoriser le code plus tard
+def check_abcd(pdd1, pdd2, pdg1, pdg2, i):
+    ad = pdd1[i]
+    bd = pdd1[i+1]
+    cd = pdd2[i]
+    dd = pdd2[i+1]
+    ag = pdg1[i+1]
+    bg = pdg1[i]
+    cg = pdg2[i+1]
+    dg = pdg2[i]
+    #cas x[i] < x[i+1]
+    if (bd == 1 and dg == 1):
+        if ((ad == 0 and dd != 0)
+        or (ad > 0 and (cd > ad or dd != ad + 1))
+        or (bg == 0 and cg != 0)
+        or (bg > 1 and cg != bg - 1)
+        or (bg == 1)):
+            return False
+    #cas x[i] > x[i+1]
+    if (bg == 1 and dd == 1):
+        if ((ag == 0 and dg != 0)
+        or (ag > 0 and (cg > ag or dg != ag + 1))
+        or (bd == 0 and cd != 0)
+        or (bd > 1 and cd != bd - 1)
+        or (bd == 1)):
+            return False
+    #Tout est cohérent sinon
+    return True
+
+#Vérifie si seq2 peut être CT-équivalente (à un swap près) à seq1
+def check_swap(seq1, seq2):
+    pdd1 = pdd(seq1)
+    pdd2 = pdd(seq2)
+    pdg1 = pdg(seq1)
+    pdg2 = pdg(seq2)
+    i = first_diff_d(pdd1, pdd2)
+    j = first_diff_g(pdg1, pdg2)
+    if i == -1 or j == -1:
+        return False
+    diff = j - i
+    if diff == 1:
+        return check_abcd(pdd1, pdd2, pdg1, pdg2, i)
+    if diff == -1:
+        return check_abcd(pdd1, pdd2, pdg1, pdg2, j)
+    if diff == 0:
+        return (check_abcd(pdd1, pdd2, pdg1, pdg2, i-1)
+                or check_abcd(pdd1, pdd2, pdg1, pdg2, i))
+    return False
+
+#Fonction outil qui onstruit la séquence '1..n' qui permet 
+#d'ensuite générer toutes les permutations à l'aide d'itertools
+def seq_n(n):
+    res = ''
+    for i in range(n):
+        res += str(i+1)
+    return res
+
+#Brute force pour des permutations de taille n en effectuant 
+#toutes les poignées de mains possibles, puis retourne
+#le nombre de matchs d'après check_swap ainsi que le nombre de
+#poignées de main
+#Décommenter la partie sur res permet de retourner une liste de
+#toutes les permutations qui ont match en plus
+def check_all(n):
+    perm = list(itertools.permutations(seq_n(n)))
+    l = len(perm)
+    check = 0
+    handshake = 0
+    #res = []
+    for i in range(l):
+        for j in range(i + 1, l):
+            if check_swap(list(perm[i]), list(perm[j])):
+                check += 1
+                #res.append((i,j))
+            handshake += 1
+    return check, handshake#, res
+
+#LEGACY CODE - USELESS AS OF NOW
+
+# def check_swap_flag_or(seq1, seq2):
+#     pdd1 = pdd(seq1)
+#     pdd2 = pdd(seq2)
+#     pdg1 = pdg(seq1)
+#     pdg2 = pdg(seq2)
+#     i = first_diff_d(pdd1, pdd2)
+#     j = first_diff_g(pdg1, pdg2)
+#     if i == -1 or j == -1:
+#         return (False, False)
+#     diff = j - i
+#     if diff == 1:
+#         return (check_abcd(pdd1, pdd2, pdg1, pdg2, i), False)
+#     if diff == -1:
+#         return (check_abcd(pdd1, pdd2, pdg1, pdg2, j), False)
+#     if diff == 0:
+#         return ((check_abcd(pdd1, pdd2, pdg1, pdg2, i-1)
+#                 or check_abcd(pdd1, pdd2, pdg1, pdg2, i)), True)
+#     return (False, False)
+
+# def check_all_flag_or(n):
+#     perm = list(itertools.permutations(seq_n(n)))
+#     l = len(perm)
+#     check = 0
+#     handshake = 0
+#     res = []
+#     for i in range(l):
+#         for j in range(i + 1, l):
+#             ref = check_swap_flag_or(list(perm[i]), list(perm[j]))
+#             if (ref == (True, True)):
+#                 check += 1
+#                 res.append((i+1,j+1))
+#             handshake += 1
+#     return check, handshake, res
+
+# def check_swap_flag_xor(seq1, seq2):
+#     pdd1 = pdd(seq1)
+#     pdd2 = pdd(seq2)
+#     pdg1 = pdg(seq1)
+#     pdg2 = pdg(seq2)
+#     i = first_diff_d(pdd1, pdd2)
+#     j = first_diff_g(pdg1, pdg2)
+#     if i == -1 or j == -1:
+#         return (False, False)
+#     diff = j - i
+#     if diff == 1:
+#         return (check_abcd(pdd1, pdd2, pdg1, pdg2, i), False)
+#     if diff == -1:
+#         return (check_abcd(pdd1, pdd2, pdg1, pdg2, j), False)
+#     if diff == 0:
+#         return ((check_abcd(pdd1, pdd2, pdg1, pdg2, i-1)
+#                 ^ check_abcd(pdd1, pdd2, pdg1, pdg2, i)), True)
+#     return (False, False)
+
+# def check_all_flag_xor(n):
+#     perm = list(itertools.permutations(seq_n(n)))
+#     l = len(perm)
+#     check = 0
+#     handshake = 0
+#     res = []
+#     for i in range(l):
+#         for j in range(i + 1, l):
+#             ref = check_swap_flag_xor(list(perm[i]), list(perm[j]))
+#             if (ref == (True, True)):
+#                 check += 1
+#                 res.append((i+1,j+1))
+#             handshake += 1
+#     return check, handshake, res
+
+#-------------------------------------------
+
+#TESTS
+
+#list(itertools.permutations('012'))
+
+#max_j(["5","6","1","3","4","2"], 4)
+#max_j(('5','6','1','3','4','2'), 2)
+
+
+#pdd(["4","5","6","1","2","7","8","3","9"])
+#pdg(["4","5","6","1","2","7","8","3","9"])
+#pdd(["4","5","6","3","1","7","8","2","9"])
+#pdg(["4","5","6","3","1","7","8","2","9"])
+
+#s1 = ["4","5","6","1","2","7","8","3","9"]
+#s2 = ["4","5","6","3","1","7","8","2","9"]
+#s3 = ("4","5","6","1","2","7","8","3","9")
+
+
+#pd1 = pdd(s1)
+#pd2 = pdd(s2)
+#pd3 = pdg(s1)
+#pd4 = pdg(s2)
+#pd5 = pdd(s3)
+
+#first_diff_d(pd1, pd2)
+#first_diff_g(pd3, pd4)
+
+#check_swap(s1, s2)
+#check_swap(s1, s1)
+
+#seq_n(3)
+
+#list(itertools.permutations('1234'))
+
+#l1 = check_all_flag_or(4)[2]
+#l2 = check_all_flag_xor(4)[2]
+
+#set(l1).symmetric_difference(set(l2))
+
+#s4 = ["1","4","2","3"]
+#s5 = ["3","2","1","4"]
+
+#first_diff_d(pdd(s4), pdd(s5))
+#first_diff_g(pdg(s4), pdg(s5))
+#pdd(s4)
+#pdd(s5)
+#pdg(s4)
+#pdg(s5)
+
+#check_all_flag_or(4)
+#check_all_flag_xor(4)
+
+check_all(3)
+check_all(4)
+check_all(5)
+check_all(6)
+check_all(7)