private int[,] swaps; //Historique des permutations. (-1 si pas de permutation)
#endregion
#region Constructeurs
public Matrice() : this(0, 0)
{
values = null;
determinant = null;
L = null;
U = null;
}
//Inverse la matrice L avec sortie pour l'affichage.
public Matrice InverseL(out List <String> display)
{
if (IsInversible())
{
Matrice ident = InitIdentite(NbrLn);
Matrice LPrime = new Matrice(NbrLn, NbrCol);
double somme = 0;
display = new List <string>();
display.Add("Etape 1: ");
display.Add("--------");
display.Add("");
//La première ligne est la même que l'identité.
for (int j = 0; j < nbrCol; j++)
{
LPrime[0, j] = ident[0, j];
display.Add(String.Format("x1" + j + " = {0,8:#0.##} = &1" + j, LPrime[0, j]));
}
//Pour chaque ligne.
for (int i = 1; i < NbrLn; i++)
{
display.Add("");
display.Add("Etape " + (i + 1) + ":");
display.Add("--------");
display.Add("");
//Pour chaque colonne.
for (int j = 0; j < NbrCol; j++)
{
somme = 0;
String tmp = "";
//Nombre d'élément de la somme.
for (int k = 0; k < i; k++)
{
tmp += " - m" + (i + 1) + (k + 1) + " * " + "x" + (k + 1) + (j + 1);
somme += L[i, k] * LPrime[k, j];
}
//Applique la formule.
LPrime[i, j] = ident[i, j] - somme;
display.Add(String.Format("x" + (i + 1) + (j + 1) + " = {0,8:#0.##} = &" + (i + 1) + (j + 1) + tmp, LPrime[i, j]));
}
}
display.Add("");
display.Add("Matrice L inversé : ");
foreach (var item in LPrime.Print())
{
display.Add(item);
}
return(LPrime);
}
else
{
throw new Exception("La matrice n'est pas inversible : déterminant = 0");
}
}
private Matrice LoadMatrice()
{
Matrice m = null;
int ln, col;
String[] temp;
temp = lines[0].Split(' ');
ln = lines.Length;
col = temp.Length;
m = new Matrice(ln, col);
for (int i = 0; i < ln; i++)
{
temp = lines[i].Split(' ');
for (int j = 0; j < col; j++)
{
m[i, j] = double.Parse(temp[j]);
}
}
return(m);
}
//Calcul le produit de deux matrices.
public Matrice Product(Matrice m)
{
//Vérifie si l'on peut multiplier les matrice entre elles.
if (nbrLn == m.nbrCol)
{
Matrice temp = new Matrice(nbrLn, m.nbrCol);
for (int i = 0; i < nbrLn; i++)
{
for (int j = 0; j < m.nbrCol; j++)
{
temp[i, j] = 0;
for (int k = 0; k < m.nbrCol; k++)
{
//Calcul le produit matricielle de [i,j]
temp[i, j] += this[i, k] * m[k, j];
}
}
}
return(temp);
}
else
{
throw new Exception("Impossible de multiplier ces matrice");
}
}
public void AfficherVerificationDecomp(Matrice mat, Matrice A, out bool flagSwaps)
{
Flux.WriteLine("===================================================================================================");
Flux.WriteLine("= Vérification A=L*U =");
Flux.WriteLine("===================================================================================================");
Flux.WriteLine();
Flux.WriteLine("Matrice A :");
foreach (var item in A.Print())
{
Flux.WriteLine(item);
}
;
flagSwaps = false;
for (int i = 0; i < mat.Swaps.GetLength(0); i++)
{
if (mat.Swaps[i, 0] != -1)
{
flagSwaps = true;
}
}
if (flagSwaps)
{
Flux.WriteLine("Après permutations.");
}
Flux.WriteLine();
}
public void AfficherVerification(Matrice A, Matrice B, Matrice res, bool check)
{
Console.WriteLine("===================================================================================================");
Console.WriteLine("= Vérification A*A(-1) = & =");
Console.WriteLine("===================================================================================================");
Console.WriteLine();
A.Display();
Console.WriteLine("");
Console.WriteLine(" *");
Console.WriteLine("");
B.Display();
Console.WriteLine("");
Console.WriteLine(" =");
Console.WriteLine("");
res.Display();
Console.WriteLine();
if (check)
{
Console.WriteLine("L'inversion de la matrice c'est bien déroulée!");
}
else
{
Console.WriteLine("Erreur : le résultat est faux!");
}
}
//Inverse la matrice avec l'affichage en sortie.
public Matrice Inverse(out List <String> display)
{
if (IsInversible())
{
Matrice inverse;
display = new List <string>();
Matrice LPrime = InverseL();
Matrice UPrime = InverseU();
inverse = UPrime.Product(LPrime);
//Permute les colonnes si il y a eu des permutation de lignes.
for (int i = Swaps.GetLength(0) - 1; i >= 0; i--)
{
if (Swaps[i, 0] != -1)
{
inverse.SwapCol(Swaps[i, 0], Swaps[i, 1]);
display.Add("Permutation de colonne : " + (Swaps[i, 0] + 1) + " <->" + (Swaps[i, 1] + 1));
}
}
return(inverse);
}
else
{
throw new Exception("La matrice n'est pas inversible : déterminant = 0");
}
}
//Triangularise la matrice par la méthode de Gauss.
public Matrice Gauss(out int[,] swaps, out double[,] m)
{
if (IsSquare())
{
Matrice temp = new Matrice(values);
double pivot;
//Initialise la sortie.
swaps = new int[nbrLn - 1, 2];
m = new double[nbrLn, nbrCol];
//Pour chaque étape. (k-1 étapes)
for (int k = 0; k < nbrLn - 1; k++)
{
pivot = temp[k, k];
//Si le pivot vaut 0 il faut permuter les lignes.
if (pivot == 0)
{
//Récupére les numéros des lignes qui permutent.
swaps[k, 0] = k;
swaps[k, 1] = k + 1;
//Permute les lignes et recalcul le pivot.
temp.SwapLn(k, k + 1);
pivot = temp[k, k];
if (pivot == 0)
{
throw new Exception("La matrice n'est pas inversible !");
}
}
else
{
//Indique que les lignes n'ont pas été permutés.
swaps[k, 0] = -1;
swaps[k, 1] = -1;
}
//Pour chaque ligne de la matrice.
//Calcul du coefficient de l'étape k.
for (int i = k + 1; i < nbrLn; i++)
{
m[i, k] = temp[i, k] / pivot;
//Met les 0.
for (int j = k; j < nbrLn; j++)
{
temp[i, j] -= m[i, k] * temp[k, j];
}
}
}
return(temp);
}
else
{
throw new Exception("La matrice n'est pas carrée : impossible d'utiliser Gauss!");
}
}
//Inverse la matrice U avec sortie pour l'affichage.
public Matrice InverseU(out List <String> display)
{
if (IsInversible())
{
Matrice ident = InitIdentite(NbrLn);
Matrice UPrime = new Matrice(NbrLn, NbrCol);
double somme = 0;
display = new List <string>();
display.Add("Etape 1: ");
display.Add("--------");
display.Add("");
//La dernière ligne.
for (int j = 0; j < nbrCol; j++)
{
UPrime[NbrLn - 1, j] = ident[NbrLn - 1, j] / U[NbrLn - 1, NbrLn - 1];
display.Add(String.Format("x" + NbrLn + (j + 1) + " = {0,8:#0.##} = &" + NbrLn + (j + 1) + "/u" + NbrLn + NbrLn, UPrime[NbrLn - 1, j]));
}
//Pour chaque ligne.
for (int i = NbrLn - 2; i >= 0; i--)
{
display.Add("");
display.Add("Etape " + (NbrLn - i) + ":");
display.Add("--------");
display.Add("");
//Pour chaque colonne.
for (int j = 0; j < NbrCol; j++)
{
somme = 0;
String tmp = "";
//Nombre d'élément de la somme.
for (int k = i + 1; k < NbrLn; k++)
{
tmp += " - u" + (i + 1) + (k + 1) + " * " + "y" + (k + 1) + (j + 1);
somme += U[i, k] * UPrime[k, j];
}
//Applique la formule.
UPrime[i, j] = (ident[i, j] - somme) / U[i, i];
display.Add(String.Format("x" + (i + 1) + (j + 1) + " = {0,8:#0.##} = (&" + (i + 1) + (j + 1) + tmp + ")/u" + (i + 1) + (i + 1), UPrime[i, j]));
}
}
display.Add("");
display.Add("Matrice U inversé : ");
foreach (var item in UPrime.Print())
{
display.Add(item);
}
return(UPrime);
}
else
{
throw new Exception("La matrice n'est pas inversible : déterminant = 0");
}
}
public Matrice(int ln, int col)
{
nbrCol = col;
nbrLn = ln;
values = new double[ln, col];
determinant = null;
L = null;
U = null;
}
public void AfficherMatriceL(Matrice mat)
{
Console.WriteLine("===================================================================================================");
Console.WriteLine("= Matrice L =");
Console.WriteLine("===================================================================================================");
Console.WriteLine();
mat.MatriceL.Display();
Console.WriteLine();
}
public void AfficherMatrice(Matrice mat)
{
Console.WriteLine("===================================================================================================");
Console.WriteLine("= Matrice à inverser =");
Console.WriteLine("===================================================================================================");
Console.WriteLine();
mat.Display();
Console.WriteLine();
}
//Initialise la sous-matrice L à partir des coeficients récupéré par Gauss.
private Matrice InitL(double[,] m)
{
Matrice L = new Matrice(m);
for (int i = 0; i < nbrLn; i++)
{
L[i, i] = 1;
}
return(L);
}
public Matrice(double[,] data)
{
//Besoin pour ne pas copier la référence.
InitData(data);
nbrCol = data.GetLength(1);
nbrLn = data.GetLength(0);
determinant = null;
L = null;
U = null;
}
public void AfficherInverse(Matrice mat, ref List <String> display)
{
Console.WriteLine("===================================================================================================");
Console.WriteLine("= Résultat de l'inversion =");
Console.WriteLine("===================================================================================================");
Console.WriteLine();
foreach (var item in display)
{
Console.WriteLine(item);
}
mat.Display();
}
public void AfficherMatrice(Matrice mat)
{
Flux.WriteLine("===================================================================================================");
Flux.WriteLine("= Matrice à inverser =");
Flux.WriteLine("===================================================================================================");
Flux.WriteLine();
foreach (var item in mat.Print())
{
Flux.WriteLine(item);
}
Flux.WriteLine();
}
public void AfficherMatriceU(Matrice mat)
{
Flux.WriteLine("===================================================================================================");
Flux.WriteLine("= Matrice U =");
Flux.WriteLine("===================================================================================================");
Flux.WriteLine();
foreach (var item in mat.MatriceU.Print())
{
Flux.WriteLine(item);
}
;
Flux.WriteLine();
}
public void AfficherInverse(Matrice mat, ref List <String> display)
{
Flux.WriteLine("===================================================================================================");
Flux.WriteLine("= Résultat de l'inversion =");
Flux.WriteLine("===================================================================================================");
Flux.WriteLine();
foreach (var item in display)
{
Flux.WriteLine(item);
}
foreach (var item in mat.Print())
{
Flux.WriteLine(item);
}
}
//Demande à l'utilisateur de saisir la matrice dans la console.
public static Matrice Saisie()
{
Matrice mat = null;
double[,] data;
int ln, col;
bool flag = false; //Détermine si la saisie se déroule correctement.
//Recommence tant que l'utilisateur n'a pas saisi une matrice.
//(Permet de ne pas retourner au menu principale si il y a une faute de frappe)
do
{
try
{
Console.WriteLine("Taille de la matrice : ");
Console.Write("Lignes ? ");
ln = int.Parse(Console.ReadLine());
Console.Write("Colonnes ? ");
col = int.Parse(Console.ReadLine());
data = new double[ln, col];
for (int i = 0; i < ln; i++)
{
for (int j = 0; j < col; j++)
{
Console.WriteLine("m" + i + j + ": ");
data[i, j] = double.Parse(Console.ReadLine());
}
}
mat = new Matrice(data);
flag = true;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}while (!flag);
Console.Clear();
return(mat);
}
public Matrice(Matrice m)
{
nbrCol = m.NbrCol;
nbrLn = m.NbrLn;
values = new double[nbrLn, nbrCol];
//Besoin pour ne pas copier la référence.
for (int i = 0; i < nbrLn; i++)
{
for (int j = 0; j < nbrCol; j++)
{
values[i, j] = m[i, j];
}
}
determinant = null;
L = null;
U = null;
}
public void AfficherPermutations(Matrice mat, out bool flagSwaps)
{
Flux.WriteLine("===================================================================================================");
Flux.WriteLine("= Permutations =");
Flux.WriteLine("===================================================================================================");
Flux.WriteLine();
flagSwaps = false;
for (int i = 0; i < mat.Swaps.GetLength(0); i++)
{
if (mat.Swaps[i, 0] != -1)
{
flagSwaps = true;
Flux.WriteLine("Lignes : " + (mat.Swaps[i, 0] + 1) + " <-> " + (mat.Swaps[i, 1] + 1));
}
}
if (!flagSwaps)
{
Flux.WriteLine("Pas de permutations.");
}
Flux.WriteLine();
}
//Initialise la matrice identité.
public static Matrice InitIdentite(int n)
{
Matrice m;
m = new Matrice(n, n);
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (i == j)
{
m[i, j] = 1;
}
else
{
m[i, j] = 0;
}
}
}
return(m);
}
//Inverse la matrice U
public Matrice InverseU()
{
if (IsInversible())
{
Matrice ident = InitIdentite(NbrLn);
Matrice UPrime = new Matrice(NbrLn, NbrCol);
double somme = 0;
//La dernière ligne.
for (int j = 0; j < nbrCol; j++)
{
UPrime[NbrLn - 1, j] = ident[NbrLn - 1, j] / U[NbrLn - 1, NbrLn - 1];
}
//Pour chaque ligne.
for (int i = NbrLn - 2; i >= 0; i--)
{
//Pour chaque colonne.
for (int j = 0; j < NbrCol; j++)
{
somme = 0;
//Nombre d'élément de la somme.
for (int k = i + 1; k < NbrLn; k++)
{
somme += U[i, k] * UPrime[k, j];
}
//Applique la formule.
UPrime[i, j] = (ident[i, j] - somme) / U[i, i];
}
}
return(UPrime);
}
else
{
throw new Exception("La matrice n'est pas inversible : déterminant = 0");
}
}
//Inverse la matrice L.
public Matrice InverseL()
{
if (IsInversible())
{
Matrice ident = InitIdentite(NbrLn);
Matrice LPrime = new Matrice(NbrLn, NbrCol);
double somme = 0;
//La première ligne est la même que l'identité.
for (int j = 0; j < nbrCol; j++)
{
LPrime[0, j] = ident[0, j];
}
//Pour chaque ligne.
for (int i = 1; i < NbrLn; i++)
{
//Pour chaque colonne.
for (int j = 0; j < NbrCol; j++)
{
somme = 0;
//Nombre d'élément de la somme.
for (int k = 0; k < i; k++)
{
somme += L[i, k] * LPrime[k, j];
}
//Applique la formule.
LPrime[i, j] = ident[i, j] - somme;
}
}
return(LPrime);
}
else
{
throw new Exception("La matrice n'est pas inversible : déterminant = 0");
}
}
//Inverse la matrice.
public void Inverse()
{
if (IsInversible())
{
Matrice LPrime = InverseL();
Matrice UPrime = InverseU();
this.values = (UPrime.Product(LPrime)).values;
//Permute les colonnes si il y a eu des permutation de lignes.
for (int i = 0; i < Swaps.GetLength(0); i++)
{
if (Swaps[i, 0] != -1)
{
SwapCol(Swaps[i, 0], Swaps[i, 1]);
}
}
}
else
{
throw new Exception("La matrice n'est pas inversible : déterminant = 0");
}
}
public void AfficherVerification(Matrice A, Matrice B, Matrice res, bool check)
{
Flux.WriteLine("===================================================================================================");
Flux.WriteLine("= Vérification A*A(-1) = & =");
Flux.WriteLine("===================================================================================================");
Flux.WriteLine();
foreach (var item in A.Print())
{
Flux.WriteLine(item);
}
Flux.WriteLine("");
Flux.WriteLine(" *");
Flux.WriteLine("");
foreach (var item in B.Print())
{
Flux.WriteLine(item);
}
Flux.WriteLine("");
Flux.WriteLine(" =");
Flux.WriteLine("");
foreach (var item in res.Print())
{
Flux.WriteLine(item);
}
Flux.WriteLine();
if (check)
{
Flux.WriteLine("L'inversion de la matrice c'est bien déroulée!");
}
else
{
Flux.WriteLine("Erreur : le résultat est faux!");
}
}
//Vérifie si deux matrices sont egales.
public bool Equals(Matrice B)
{
bool check = true;
int i = 0, j = 0;
if (nbrLn == B.nbrLn && nbrCol == B.nbrCol)
{
while (i < B.nbrLn && check == true)
{
while (j < B.nbrCol && check == true)
{
check = Math.Round(values[i, j]) == B[i, j];
j++;
}
i++;
}
}
else
{
check = false;
}
return(check);
}
public void AfficherVerificationDecomp(Matrice mat, Matrice A, out bool flagSwaps)
{
Console.WriteLine("===================================================================================================");
Console.WriteLine("= Vérification A=L*U =");
Console.WriteLine("===================================================================================================");
Console.WriteLine();
Console.WriteLine("Matrice A :");
A.Display();
flagSwaps = false;
for (int i = 0; i < mat.Swaps.GetLength(0); i++)
{
if (mat.Swaps[i, 0] != -1)
{
flagSwaps = true;
}
}
if (flagSwaps)
{
Console.WriteLine("Après permutations.");
}
Console.WriteLine();
}
//Décompose la matrice en deux sous matrice L et U avec une sortie de l'affichage.
public void DecompositionLU(out List <String> display)
{
double[,] m;
U = Gauss(out swaps, out m, out display);
L = InitL(m);
}
//Décompose la matrice en deux sous matrice L et U.
public void DecompositionLU()
{
double[,] m;
U = Gauss(out swaps, out m);
L = InitL(m);
}
