#define true 1
#define false 0
#define crit_arret 1e^-3
#include "BIBLIO.h"
#include <math.h>
int PivotDeGauss(int dimension, double** Matrice_A1, double* Matrice_B)
{
    double* MatriceX = NULL;
    double** Matrice_Triangulee = NULL;
    int n, y, x, j, k, i;
    double q, pivot, somme = 0;
    n = dimension;

    Matrice_Triangulee = (double**) malloc (sizeof(double*)*n);
    MatriceX = malloc(sizeof(double)*n);

    if(Matrice_A1 == NULL || Matrice_B == NULL || MatriceX == NULL || Matrice_Triangulee == NULL)
    {
        printf("Erreur dans l'allocation dynamique \n");
        return false;
    }
    for (i=0; i<n; i++)
    {
        Matrice_Triangulee[i]=(double*) malloc (sizeof(double)*n);
    }

    for(x = 0; x<n; x++)
    {
        for(y = 0; y<n; y++)
        {
            Matrice_Triangulee[x][y] = Matrice_A1[x][y];
            printf(" %2.f ", Matrice_A1[x][y]);
        }
        printf("\n");
    }

    for (j = 0; j<n; j++)
    {
        pivot = Matrice_Triangulee[j][j];
        if(pivot == 0)
        {
            printf("Erreur pivot nul\n");
            return false;
        }
        for(i=j+1; i<n; i++)//Triang
        {
            q = Matrice_Triangulee[i][j]/pivot;
            for (k=0;k<n; k++)
            {
                Matrice_Triangulee[i][k] = Matrice_Triangulee[i][k] - q*Matrice_Triangulee[j][k];
            }
            Matrice_B[i] = Matrice_B[i]-q*Matrice_B[j];
        }
    }
    printf("\n MAT TRIANG \n");
    for(x = 0; x<dimension; x++)
    {
        for(y = 0; y<dimension; y++)
        {
            printf(" %2.f ", Matrice_Triangulee[x][y]);
        }
        printf("\n");
    }
    MatriceX[dimension-1] = Matrice_B[dimension-1]/Matrice_Triangulee[dimension-1][dimension-1];
    printf("%f\n", MatriceX[2]);
    printf("%f\n", Matrice_B[2]);
    printf("%f\n", Matrice_Triangulee[2][2]);
    getchar();
    for(i=dimension-2; i>=0; i--)
    {
        somme = 0;
        for(j = i+1; j<dimension; j++)
        {
            somme = somme + Matrice_Triangulee[i][j]*MatriceX[j];
        }
        MatriceX[i] = (Matrice_B[i]-somme)/Matrice_Triangulee[i][i];
    }

    for(i = 0; i<n; i++)
    {
        printf("%.2f \n", MatriceX[i]);
    }

    for(i=0 ; i < dimension ; i++)
    {
        free(Matrice_Triangulee[i]);
    }
    free(Matrice_Triangulee);
    free(MatriceX);
    return true;
}



int GaussSeidel(int dimension, double** Matrice_A2, double* Matrice_B)
{

    int i, j, k, condition = 0;
    double sommeA, sommeB, comp_max;
    double* VecteurX0 = NULL;
    double* VecteurX1 = NULL;
    double* VecteurX2 = NULL;
    VecteurX0 = malloc(sizeof(double)*dimension);
    VecteurX1 = malloc(sizeof(double)*dimension);
    VecteurX2 = malloc(sizeof(double)*dimension);
    if(VecteurX0 == NULL || VecteurX1 == NULL || VecteurX2 == NULL)
    {
        printf("Erreur dans l'allocation dynamique \n");
        return false;
    }

    for( k = 0; k<dimension; k++)
    {
        VecteurX1[k] = k+1; // Cette boucle nous permet d'initialiser le premier tour du vecteur x
    }
    do
    {
        condition++;
        for(i = 0; i<dimension; i++)
        {
            sommeA = 0;
            sommeB = 0;
            for(j = i; j<dimension; j++)
            {
                sommeA = sommeA + Matrice_A2[i][j]*VecteurX1[j];
            }
            for(j = 0; j<i; j++)
            {
                sommeB = sommeB + Matrice_A2[i][j]*VecteurX2[j];
            }

            VecteurX2[i] = (Matrice_B[i]-sommeA-sommeB)/Matrice_A2[i][i];
        }

        comp_max = 0;
        for(i = 0; i<dimension; i++)
        {
             VecteurX0[i] = fabs(VecteurX1[i] - VecteurX2[i]);
             VecteurX1[i] = VecteurX2[i];
             printf("%.9f\n", VecteurX0[i]);
            if(VecteurX0[i] > comp_max)
            {
                  comp_max = VecteurX0[i];
            }
        }

    }while(comp_max > 0.001);
    printf("%d BOUCLES ! ", condition);


return true;
}