def test_matrice_permutation_inverse():
    nbErreur = 0
    for i in range(1, 20):
        permut = permutation.permutation_aleatoire(i)
        mat = permutation.matrice_permutation(permut)
        if mat != permutation.matrice_permutation_inverse(
                permutation.matrice_permutation_inverse(mat)) or not (
                    permutation.est_carree(
                        permutation.matrice_permutation_inverse(mat))):
            nbErreur += 1
            print "Erreur lors du test de matrice_permutation_inverse(", mat, ")"
    return nbErreur
def test_est_carree():
    nbErreur = 0
    listeMatrice = []
    listeResultat = []
    listeMatrice.append([[1,1],[2,2]])
    listeResultat.append(True)
    listeMatrice.append([[1,1],[1,1],[1,1]])
    listeResultat.append(False)
    listeMatrice.append([[1,1]])
    listeResultat.append(False)
    listeMatrice.append([[1,1,1],[1,1]])
    listeResultat.append(False)
    listeMatrice.append([[1,1,1],[1,1,1],[1,1,1]])
    listeResultat.append(True)
    for i, x in enumerate(listeMatrice):
        if listeResultat[i] != permutation.est_carree(x):
            nbErreur += 1
            print("Erreur lors du test de est_carree(", x,") \n" )
    return nbErreur
def test_est_carree():
    nbErreur = 0
    listeMatrice = []
    listeResultat = []
    listeMatrice.append([[1, 1], [2, 2]])
    listeResultat.append(True)
    listeMatrice.append([[1, 1], [1, 1], [1, 1]])
    listeResultat.append(False)
    listeMatrice.append([[1, 1]])
    listeResultat.append(False)
    listeMatrice.append([[1, 1, 1], [1, 1]])
    listeResultat.append(False)
    listeMatrice.append([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
    listeResultat.append(True)
    for i, x in enumerate(listeMatrice):
        if listeResultat[i] != permutation.est_carree(x):
            nbErreur += 1
            print("Erreur lors du test de est_carree(", x, ") \n")
    return nbErreur
def test_matrice_permutation():
    compte = 0
    listeUplet =[]
    listeMatrice =[]
    listeUplet.append([0])
    listeMatrice.append([[1]])
    listeUplet.append([0,1,2])
    listeMatrice.append([[1,0,0],[0,1,0],[0,0,1]])
    listeUplet.append([2,0,1])
    listeMatrice.append([[0,1,0],[0,0,1],[1,0,0]])
    listeUplet.append([2,1,0,3])
    listeMatrice.append([[0,0,1,0],[0,1,0,0],[1,0,0,0],[0,0,0,1]])
    listeUplet.append([4,3,0,1,2])
    listeMatrice.append([[0,0,1,0,0],[0,0,0,1,0],[0,0,0,0,1],[0,1,0,0,0],[1,0,0,0,0]])
    for i, x in enumerate(listeUplet):
        m = permutation.matrice_permutation(x)
        if (listeMatrice[i] != m) or not(permutation.est_carree(m)):
            compte += 1
            print "Erreur lors du test de matrice_permutation(", x, ") \n"
    return compte
def test_matrice_permutation():
    compte = 0
    listeUplet = []
    listeMatrice = []
    listeUplet.append([0])
    listeMatrice.append([[1]])
    listeUplet.append([0, 1, 2])
    listeMatrice.append([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
    listeUplet.append([2, 0, 1])
    listeMatrice.append([[0, 1, 0], [0, 0, 1], [1, 0, 0]])
    listeUplet.append([2, 1, 0, 3])
    listeMatrice.append([[0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0],
                         [0, 0, 0, 1]])
    listeUplet.append([4, 3, 0, 1, 2])
    listeMatrice.append([[0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1],
                         [0, 1, 0, 0, 0], [1, 0, 0, 0, 0]])
    for i, x in enumerate(listeUplet):
        m = permutation.matrice_permutation(x)
        if (listeMatrice[i] != m) or not (permutation.est_carree(m)):
            compte += 1
            print "Erreur lors du test de matrice_permutation(", x, ") \n"
    return compte
def test_matrice_permutation_inverse():
    nbErreur = 0
    for i in range(1,20) :
        permut = permutation.permutation_aleatoire(i)
        mat = permutation.matrice_permutation(permut)
        if mat != permutation.matrice_permutation_inverse(permutation.matrice_permutation_inverse(mat)) or not(permutation.est_carree(permutation.matrice_permutation_inverse(mat))):
            nbErreur += 1
            print "Erreur lors du test de matrice_permutation_inverse(", mat, ")"
    return nbErreur
def test_decomposition_plu():
    nbErreur = 0
    #Tests avec des matrices aleatoires
    for i in range(2, 20):
        mat = permutation.matrice_aleatoire(i)
        PLU = decomposition.decomposition_plu(mat)
        temp = produit(PLU[0], PLU[1])
        res = produit(temp, PLU[2])
        if not (matrices_egales(res, mat)):
            nbErreur += 1
            print "erreur lors du produit de trois matrices", mat
        if not (decomposition.triangulaire_inf(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas triangulaire inferieure"
        if not (decomposition.triangulaire_sup(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas triangulaire superieure"
        if not (permutation.est_carree(PLU[0])):
            nbErreur += 1
            print "erreur", mat, "P n'est pas carree"
        if not (permutation.est_carree(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas carree"
        if not (permutation.est_carree(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas carree"

    #Tests avec des matrices necessitants des permutations:
    for i in range(2, 20):
        mat = permutation.matrice_aleatoire(i)
        lig = random.randint(0, i - 2)
        for j in range(i - 1):
            mat[lig][j] = 0
        PLU = decomposition.decomposition_plu(mat)
        temp = produit(PLU[0], PLU[1])
        res = produit(temp, PLU[2])
        if not (matrices_egales(res, mat)):
            nbErreur += 1
            print "erreur lors du produit de trois matrices", mat
        if not (decomposition.triangulaire_inf(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas triangulaire inferieure"
        if not (decomposition.triangulaire_sup(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas triangulaire superieure"
        if not (permutation.est_carree(PLU[0])):
            nbErreur += 1
            print "erreur", mat, "P n'est pas carree"
        if not (permutation.est_carree(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas carree"
        if not (permutation.est_carree(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas carree"

    #Test avec des matrices ayant des colonnes nulles
    for i in range(10, 20):
        mat = permutation.matrice_aleatoire(i)
        for j in range(0, i):
            mat[j][1] = mat[j][0]
            mat[j][3] = mat[j][2]
            mat[j][5] = mat[j][4]
            mat[0][j] = 0
        PLU = decomposition.decomposition_plu(mat)
        temp = produit(PLU[0], PLU[1])
        res = produit(temp, PLU[2])
        if not (matrices_egales(res, mat)):
            nbErreur += 1
            print "erreur lors du produit de trois matrices", mat
        if not (decomposition.triangulaire_inf(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas triangulaire inferieure"
        if not (decomposition.triangulaire_sup(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas triangulaire superieure"
        if not (permutation.est_carree(PLU[0])):
            nbErreur += 1
            print "erreur", mat, "P n'est pas carree"
        if not (permutation.est_carree(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas carree"
        if not (permutation.est_carree(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas carree"

    #Tests avec des matrices choisies
    listeMatrice = []
    listeMatrice.append([[1, 2, 1], [3, 6, 5], [2, 2, 2]])
    listeMatrice.append([[1, 2, 1, 1], [3, 6, 5, 4], [2, 2, 2, 1],
                         [2, 3, 4, 1]])
    listeMatrice.append([[1, 2, 1, 1], [3, 6, 3, 4], [2, 2, 2, 1],
                         [2, 3, 4, 1]])
    listeMatrice.append([[1, 2, 1, 1], [3, 6, 3, 4], [4, 2, 4, 1],
                         [2, 3, 4, 1]])
    listeMatrice.append([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
                         [2, 2, 2, 2, 2, 2, 2, 2, 2, 8],
                         [1, 2, 4, 3, 4, 4, 8, 6, 2, 1],
                         [6, 1, 2, 4, 3, 7, 6, 5, 3, 1],
                         [1, 2, 4, 1, 0, 0, 0, 1, 4, 2],
                         [12, 4, 3, 8, 6, 1, -3, 1, 8, 8],
                         [8, 4, 6, 3, 4, 5, 2, 1, 1, 1],
                         [-12, 3, 4, 5, 0, 0, 1, 3, 2, 1],
                         [7, 7, 5, 2, 1, 4, 9, 6, 3, 4],
                         [-3, -7, 1, 2, 0, 0, 8, 4, 6, 7]])
    for mat in listeMatrice:
        PLU = decomposition.decomposition_plu(mat)
        temp = produit(PLU[0], PLU[1])
        res = produit(temp, PLU[2])
        if not (matrices_egales(res, mat)):
            nbErreur += 1
            print "erreur lors du produit de trois matrices", mat
        if not (decomposition.triangulaire_inf(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas triangulaire inferieure"
        if not (decomposition.triangulaire_sup(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas triangulaire superieure"
        if not (permutation.est_carree(PLU[0])):
            nbErreur += 1
            print "erreur", mat, "P n'est pas carree"
        if not (permutation.est_carree(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas carree"
        if not (permutation.est_carree(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas carree"
    return nbErreur
def test_decomposition_plu():
    nbErreur = 0
    #Tests avec des matrices aleatoires
    for i in range(2,20):
        mat = permutation.matrice_aleatoire(i)
        PLU = decomposition.decomposition_plu(mat)
        temp = produit(PLU[0], PLU[1])
        res = produit(temp, PLU[2])
        if not(matrices_egales(res,mat)):
            nbErreur += 1
            print "erreur lors du produit de trois matrices", mat
        if not(decomposition.triangulaire_inf(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas triangulaire inferieure"
        if not(decomposition.triangulaire_sup(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas triangulaire superieure"
        if not(permutation.est_carree(PLU[0])):
            nbErreur += 1
            print "erreur", mat, "P n'est pas carree"
        if not(permutation.est_carree(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas carree"
        if not(permutation.est_carree(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas carree"

    #Tests avec des matrices necessitants des permutations:
    for i in range(2, 20):
        mat = permutation.matrice_aleatoire(i)
        lig = random.randint(0, i-2)
        for j in range(i-1):
            mat[lig][j] = 0
        PLU = decomposition.decomposition_plu(mat)
        temp = produit(PLU[0], PLU[1])
        res = produit(temp, PLU[2])
        if not(matrices_egales(res,mat)):
            nbErreur += 1
            print "erreur lors du produit de trois matrices", mat
        if not(decomposition.triangulaire_inf(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas triangulaire inferieure"
        if not(decomposition.triangulaire_sup(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas triangulaire superieure"
        if not(permutation.est_carree(PLU[0])):
            nbErreur += 1
            print "erreur", mat, "P n'est pas carree"
        if not(permutation.est_carree(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas carree"
        if not(permutation.est_carree(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas carree"

    #Test avec des matrices ayant des colonnes nulles
    for i in range(10,20):
        mat = permutation.matrice_aleatoire(i)
        for j in range(0,i):
            mat[j][1] = mat[j][0]
            mat[j][3] = mat[j][2]
            mat[j][5] = mat[j][4]
            mat[0][j] = 0
        PLU = decomposition.decomposition_plu(mat)
        temp = produit(PLU[0], PLU[1])
        res = produit(temp, PLU[2])
        if not(matrices_egales(res,mat)):
            nbErreur += 1
            print "erreur lors du produit de trois matrices", mat
        if not(decomposition.triangulaire_inf(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas triangulaire inferieure"
        if not(decomposition.triangulaire_sup(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas triangulaire superieure"
        if not(permutation.est_carree(PLU[0])):
            nbErreur += 1
            print "erreur", mat, "P n'est pas carree"
        if not(permutation.est_carree(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas carree"
        if not(permutation.est_carree(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas carree"

    #Tests avec des matrices choisies
    listeMatrice = []
    listeMatrice.append([[1,2,1],[3,6,5],[2,2,2]])
    listeMatrice.append([[1,2,1,1],[3,6,5,4],[2,2,2,1],[2,3,4,1]])
    listeMatrice.append([[1,2,1,1],[3,6,3,4],[2,2,2,1],[2,3,4,1]])
    listeMatrice.append([[1,2,1,1],[3,6,3,4],[4,2,4,1],[2,3,4,1]])
    listeMatrice.append([[1,1,1,1,1,1,1,1,1,1],[2,2,2,2,2,2,2,2,2,8],[1,2,4,3,4,4,8,6,2,1],[6,1,2,4,3,7,6,5,3,1],[1,2,4,1,0,0,0,1,4,2],[12,4,3,8,6,1,-3,1,8,8],[8,4,6,3,4,5,2,1,1,1],[-12,3,4,5,0,0,1,3,2,1],[7,7,5,2,1,4,9,6,3,4],[-3,-7,1,2,0,0,8,4,6,7]])
    for mat in listeMatrice :
        PLU = decomposition.decomposition_plu(mat)
        temp = produit(PLU[0], PLU[1])
        res = produit(temp, PLU[2])
        if not(matrices_egales(res,mat)):
            nbErreur += 1
            print "erreur lors du produit de trois matrices", mat
        if not(decomposition.triangulaire_inf(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas triangulaire inferieure"
        if not(decomposition.triangulaire_sup(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas triangulaire superieure"
        if not(permutation.est_carree(PLU[0])):
            nbErreur += 1
            print "erreur", mat, "P n'est pas carree"
        if not(permutation.est_carree(PLU[1])):
            nbErreur += 1
            print "erreur", mat, "L n'est pas carree"
        if not(permutation.est_carree(PLU[2])):
            nbErreur += 1
            print "erreur", mat, "U n'est pas carree"
    return nbErreur