Example #1
0
def test_resolution_cramer():
    nbErreur = 0
    for i in range(2, 20):
        A = permutation.matrice_aleatoire(i)
        while applications.determinant_plu(A) == 0:
            A = permutation.matrice_aleatoire(i)
        B = [random.randint(-10, 10) for j in range(i)]
        res = applications.resolution_cramer(A, B)
        erreur = False
        for j in range(i):
            somme = 0
            for k in range(i):
                somme += A[j][k] * res[k]
            if round(somme, 0) != B[j]:
                erreur = True
        if erreur:
            nbErreur += 1
            print "erreur lors du test de :"
            print "A = ", A
            print "B = ", B

    #On compare maintenant les resultats obtenus grace a notre algorithme
    #de decomposition a ceux obtenus avec les decompositions de sage
    listeSage = []
    listeMatrice = []
    listeB = []

    listeSage.append([[[0, 1], [1, 0]], [[1, 0], [1 / 2., 1]], [[2, -2],
                                                                [0, 2]]])
    listeMatrice.append([[1, 1], [2, -2]])
    listeB.append([1, 3])

    listeSage.append([[[0, 0, 1], [1, 0, 0], [0, 1, 0]],
                      [[1, 0, 0], [2 / 3., 1, 0], [1 / 3., 0, 1]],
                      [[3, 6, 5], [0, -2, -4 / 3.], [0, 0, -2 / 3.]]])
    listeMatrice.append([[1, 2, 1], [3, 6, 5], [2, 2, 2]])
    listeB.append([2, 5, 3])

    for i in range(len(listeSage)):
        P, L, U = listeSage[i]
        res1 = applications.resolution_cramer_avec_plu(P, L, U, listeB[i])
        res2 = applications.resolution_cramer(listeMatrice[i], listeB[i])

        if not (liste_egale(res1, res2)):
            nbErreur += 1
            print "erreur lors du test de :"
            print "mat : ", listeMatrice[i]
            print "B :", listeB[i]
            print "Le resultat varie selon la decomposition utilisee"
            print "Le resultat obtenu avec la decomposition de sage est"
            print res1
            print "Le resultat obtenu avec notre de composition est "
            print res2
    return nbErreur
def test_determinant_plu():
    nbErreur = 0
    # On utilise ici l'algorithme de calcul du determinant recursif
    # on doit donc se limiter a des matrices de petite taille
    for i in range(1, 5):
        mat = permutation.matrice_aleatoire(i)
        if determinant(mat, 0) != round(applications.determinant_plu(mat),0):
            nbErreur += 1
            print "Erreur lors du test de ", mat
            print ""
    #Test avec des matrices necessitants des permutations
    listMat =[]
    listMat.append([[2,4,2,0],[1,3,1,0],[1,2,1,3],[1,2,2,1]])
    listMat.append([[0,4,2,0],[1,3,1,0],[1,2,1,3],[1,2,2,1]])
    listMat.append([[0,3,1,0],[2,4,2,0],[1,2,1,3],[1,2,2,1]])
    for mat in listMat:
        if determinant(mat, 0) != round(applications.determinant_plu(mat),0):
            nbErreur += 1
            print "Erreur lors du test de ", mat
            print ""
    return nbErreur
Example #3
0
def test_determinant_plu():
    nbErreur = 0
    # On utilise ici l'algorithme de calcul du determinant recursif
    # on doit donc se limiter a des matrices de petite taille
    for i in range(1, 5):
        mat = permutation.matrice_aleatoire(i)
        if determinant(mat, 0) != round(applications.determinant_plu(mat), 0):
            nbErreur += 1
            print "Erreur lors du test de ", mat
            print ""
    #Test avec des matrices necessitants des permutations
    listMat = []
    listMat.append([[2, 4, 2, 0], [1, 3, 1, 0], [1, 2, 1, 3], [1, 2, 2, 1]])
    listMat.append([[0, 4, 2, 0], [1, 3, 1, 0], [1, 2, 1, 3], [1, 2, 2, 1]])
    listMat.append([[0, 3, 1, 0], [2, 4, 2, 0], [1, 2, 1, 3], [1, 2, 2, 1]])
    for mat in listMat:
        if determinant(mat, 0) != round(applications.determinant_plu(mat), 0):
            nbErreur += 1
            print "Erreur lors du test de ", mat
            print ""
    return nbErreur
def test_resolution_cramer():
    nbErreur = 0
    for i in range (2, 20):
        A = permutation.matrice_aleatoire(i)
        while applications.determinant_plu(A) == 0:
            A = permutation.matrice_aleatoire(i)
        B = [random.randint(-10,10) for j in range(i)]
        res = applications.resolution_cramer(A, B)
        erreur = False
        for j in range(i):
            somme = 0
            for k in range(i):
                somme += A[j][k] * res[k]
            if round(somme,0) != B[j] :
                erreur = True
        if erreur:
            nbErreur += 1
            print "erreur lors du test de :"
            print "A = ", A
            print "B = ", B

    #On compare maintenant les resultats obtenus grace a notre algorithme
    #de decomposition a ceux obtenus avec les decompositions de sage
    listeSage=[]
    listeMatrice =[]
    listeB = []

    listeSage.append([[[0,1],[1,0]],[[1,0],[1/2.,1]],[[2,-2],[0,2]]])
    listeMatrice.append([[1,1],[2,-2]])
    listeB.append([1,3])

    listeSage.append([[[0,0,1],[1,0,0],[0,1,0]],[[1,0,0],[2/3.,1,0],[1/3.,0,1]], [[3,6,5],[0,-2,-4/3.],[0,0,-2/3.]]])
    listeMatrice.append([[1,2,1],[3,6,5],[2,2,2]])
    listeB.append([2,5,3])

    for i in range(len(listeSage)):
        P,L,U = listeSage[i]
        res1 = applications.resolution_cramer_avec_plu(P, L, U, listeB[i])
        res2 = applications.resolution_cramer(listeMatrice[i], listeB[i])

        if  not(liste_egale(res1,res2)) :
            nbErreur += 1
            print "erreur lors du test de :"
            print "mat : ",listeMatrice[i]
            print "B :", listeB[i]
            print "Le resultat varie selon la decomposition utilisee"
            print "Le resultat obtenu avec la decomposition de sage est"
            print res1
            print "Le resultat obtenu avec notre de composition est "
            print res2
    return nbErreur