Discussion :

[sahoumaa]

Bonsoir
Comme le sujet le montre j'ai besoin d'un petit code qui calcule l'inverse d'une matrice carrée de taille n quelconque pour pouvoir déchiffrer un message crypté à l'aide de la méthode de Hill
Merci

[dotEden]

Bonsoir,

Je ne suis pas sur de me rappeler ce qu'est une matrice inverse, en tout cas, si c'est bien la transposée dont tu parles :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class Matrix
{
    private final int       numberLines;
    private final int       numberColumns;
    private       array[][] fields;
 
    public Matrix(int numberLines, int numberColumns)
    {
        this.numberLines   = numberLines;
        this.numberColumns = numberColumns;
    }
 
    // accesseurs
    //...
 
    /**
     * Methode pour obtenir la transposee de la matrice actuelle
     *
     * @return Matrix
     */
    public Matrix getTranspose()
    {
        Matrix transpose = new Matrix(this.numberColumns, this.numberLines);
 
        for (int indexColumn = 0, indexColumn < this.numberColumns, indexColumn++) {
            for (int indexLine = 0, indexLine < this.numberLines, indexLine++) {
                transpose.setField(indexLine, indexColumn) =   this.setField(indexColumn, indexLine);
            }
        }
 
        return transpose;
    }
}

Essaye d'inverser les lignes avec les colonnes si ça ne marche pas, je confond toujours

Cordialement,

--

.eden

[thelvin]

Je ne suis pas sur de me rappeler ce qu'est une matrice inverse,

Une matrice inverse, c'est l'inverse de la matrice en question.

Autrement dit, l'inverse d'une matrice A est la matrice B telle que A multipliée par B est la matrice unitaire de même ordre que A.

Wikipédia indique comment calculer l'inverse d'une matrice, mais ça c'est seulement pour s'intéresser à la théorie.
En pratique, ce qu'il faut faire, c'est prendre une bibliothèque externe de manipulations de matrices en Java, avec je suppose gestion des valeurs exactes, et utiliser l'inversion de matrice de cette bibliothèque.

Il en existe plein, il suffit d'en essayer quelques-unes.

[dotEden]

Bonjour,

Autrement dit, l'inverse d'une matrice A est la matrice B telle que A multipliée par B est la matrice unitaire de même ordre que A.

Oui donc il s'agit bien de la transposée, merci de confirmer. Sinon oui il doit bien y avoir une bibliothèque qui permet de le faire.

Cordialement,

--

.eden

[tchize_]

non ce n'est pas la transposée, c'est l'inverse, qui est vachement plus hard a calculer, quand elle est calculable.

[wax78]

Sinon oui il doit bien y avoir une bibliothèque qui permet de le faire.

UJMP ou Colt par exemple mais il y'en a d'autres

[sahoumaa]

Merci à vous tous pour vos contributions!!!
j'ai réglé le problème voilà j'ai créé une classe qui permet de calculer l'inverse en utilisant la matrice transposé et la comatrice
mais dans ce cas particulier je travaille en base 26 c'est à dire que les nombres qui forment la matrice varient entre 0 et 25 , C'est l'algo de Hill qui l'impose

voici ma classe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
package matrice;
 
 
public class Matrix {
	private int[][] matrice;
	int n;
 
	public Matrix(int[][] tab,int n)
	{   
		this.n=n;
		matrice = new int[n][n];
		for(int i=0;i<n;i++)
			for(int j=0;j<n;j++)
				matrice[i][j]=tab[i][j]%26;
	}
 
	public Matrix(int n)
	{   
		this.n=n;
		matrice = new int[n][n];
	}
 
 
	public int getElt(int n, int p)
	{
		return this.matrice[n][p];
	}
 
 
	public void setElt(int value, int n, int p)
	{
		this.matrice[n][p] = value%26;
	}
 
 
	public Matrix sousMatrice ( int ib , int jb )
	{
		Matrix B = new Matrix( this.n - 1);
		int ir = 0, jr = 0;
		for ( int i = 0 ; i < this.n ; i++ )
		{
			for ( int j = 0 ; j < this.n ; j++ )
			{
				if( i != (ib) && j != (jb) )
				{
					B.setElt(this.getElt(i,j), ir, jr);
					if ( jr < B.n-1 ) jr++;
					else { jr = 0; ir++; }
				}
			}
		}
		return B;
	}
 
	public int determinant()
	{
 
		int det = 0;
		Matrix B;
		//Conditions d'arrêt
		if ( this.n == 1 ) return this.getElt(0,0);
		if ( this.n == 2 ) {
			  det=(this.getElt(0,0)*this.getElt(1,1) - this.getElt(0,1)*this.getElt(1,0) )%26;
			  if (det<0) det+=26;
			  return det;
		}
		//Traitement par récursivité
		for ( int j = 0 ; j < this.n ; j++ )
		{
			B = this.sousMatrice( 0 , j );
			if ( j % 2 == 0 ) { 
							det += this.getElt(0,j)*B.determinant(); 
							det%=26;
							 if (det<0) det+=26;
							  }
			else {
				det += -1*this.getElt(0,j)*B.determinant(); 
				det%=26;
				 if (det<0) det+=26;
				}
		}
		return det;
	}
 
 
	public Matrix transpose()
	{
		int[][] TableauTemporaire = new int[n][n];
		for ( int j = 0 ; j < n ; j++ )
		{
		for ( int i = 0 ; i < n ; i++ )
		{
			TableauTemporaire[i][j] = matrice[j][i];
		}
		}
		return new Matrix( TableauTemporaire,n );
	}
 
 
	public Matrix comatrice()
	{
		Matrix B = new Matrix( this.n);
		Matrix S;
		for ( int i = 0 ; i < B.n ; i++ )
		{
			for ( int j = 0 ; j < B.n ; j++ )
			{
				S = this.sousMatrice( i , j );
				if( ( i + j ) % 2 == 0 ) { B.setElt(S.determinant(), i, j); }
				else { B.setElt(-1 * S.determinant(), i, j); }
			}
 
 
		}
		return B;
	}
 
	public Matrix Inverse()
	{
		int det = this.determinant();
		int inv=FctAlgEuc(det,26);
		if(inv<0) inv+=26;
		Matrix t_Comatrice = this.comatrice().transpose();
		Matrix Inverse= new Matrix(n);
		for ( int i = 0 ; i < n ; i++ )
		{
			for ( int j = 0 ; j < n ; j++ )
			{
			  Inverse.setElt(inv * t_Comatrice.getElt(i, j), i, j); 
			  if(Inverse.getElt(i,j)<0)
				  Inverse.setElt(inv * t_Comatrice.getElt(i, j)+26, i, j);
			}
 
 
		}
		return Inverse;
	}
 
	public int[][] getMatrice() {
		return matrice;
	}
 
 
	public static Matrix produit(Matrix A,Matrix B,int k)
	{
		int[][] tab= new int[k][k];
	  for(int i=0;i<k;i++)
	     for(int j=0;j<k;j++)
	     {
	         tab[i][j]=0;
	         for(int l=0;l<k;l++)
	        	 tab[i][j]+= A.getElt(i,l) * B.getElt(l,j);
 
	     }
	   Matrix pro=new Matrix(tab,k);
	   return pro;
	}
 
 
}

[dotEden]

Bonsoir,

@tchize_ : Je dois avouer que tu m'as un peu raffraichie la mémoire, je n'ai plus eu à utiliser les matrices depuis des années, merci pour cet enrichissement.


Cordialement,

--

.eden