#include <stdio.h>
#include <math.h>

double dominante(int n, double matriz[][n+1]){                                //ESSA É A FUNÇÃO PRA DEIXAR A FUNÇÃO DOMINANTE
    int i,j,k, posicao_maior;                       //DECLARA-SE UMA VARIAVEL PARA GUARDAR A POSIÇAO DO MAIOR NUMERO DA LINHA, A SOMA PARA
    double auxiliar,soma,contador_true;             //GUARDAR O VALOR DA SOMA DOS COEFICIENTES DA LINHA != Aii, "AUXILIAR" PARA AJUDAR NA TROCA DE LINHA

                                                   //CPNTADOR_TRUE PARA VERIFICAR SE Aii > SOMA.

 do{
   contador_true = 0;                             //AQUI, O PROGRAMA VAI VERIFICAR A POSIÇÃO j DO MAIOR TERMO DA LINHA E VAI MUDAR AS LINHAS DE TAL FORMA
                                                  //QUE ESSE TERMO FIQUE NA LINHA COM O MESMO VALOR DE j DO MAIOR TERMO. ASSIM TEREMOS UMA DIAGONAL SEMPRE
  for(i = 0 ; i < n; i++){                        //COM O MAIOR TERMO DA LINHA.

    auxiliar = fabs(matriz[i][i]);               // <----GUARDA O TERMO DA DIAGONAL EM AUXILIAR.
    for(j=0 ;j < n ;j ++){
        if(fabs(matriz[i][j]) > auxiliar){  //<-----VERIFICA SE O TERMO Aij É MAIOR Q O DO MAIOR TERMO VERIFICADO ANTERIORMENTE.
           auxiliar = matriz[i][j];             //CASO NÃO ELE SEGE VERIFICANDO OS OUTROS TERMOS. CASO SIM, AUXILIAR FICA COM O SEU VALOR E SE GUARDA
           posicao_maior = j;                  //A SUA POSIÇÃO PARA TROCA-LO DE LINHA FUTURAMENTE.
          }
        }
      if(auxiliar != matriz[i][i]){
      for(k = 0; k < n + 1; k ++){
                auxiliar = matriz[posicao_maior][k];      //TROCA O AS LINHAS Q TEM O MAIOR TERMO Aij PELA LINHA Aj(OS MAIORES TERMOS DA LINHA SEMPRE FICARÃO
                matriz[posicao_maior][k] = matriz[i][k];  //NA POSIÇÃO DA DIAGONAL APÓS ESSA FUNÇÃO RODAR.
                matriz[i][k] = auxiliar;
    }
   }
  }
  for(i=0; i < n; i++){                            //NESTA PARTE A FUNÇÃO VERIFICA SE A MATRIZ FICOU REALMENTE DIAGONAL DOMINANTE.
    soma= 0;                                       //TODA VEZ Q UMA LINHA TEM Aij > SOMA, O CONTADOR_TRUE SOMA + 1
    for(j = 0; j < n; j ++){                       // O LAÇO SÓ É QUEBRADO QUANDO CONTADO_TRUE FOR IGUAL AO TAMANHO DE LINHAS DO SISTEMA.
        if(i!= j){
            soma = soma + fabs(matriz[i][j]);
        }
    }
    if(fabs(matriz[i][i]) >= soma){
        contador_true++;
    }

  }
 }while(contador_true < n);
}
int VerificaDominancia (int n, double matriz[][n +1 ]){                       //FUNÇÃO Q VERIFICA SE É OU N DOMINANTE

    int i,j,contador_true = 0;
    double soma;

    for(i=0; i < n; i++){
    soma = 0;
    for(j = 0; j < n; j ++){
        if(i!= j){
            soma = soma + fabs(matriz[i][j]);
        }
    }
    if(fabs(matriz[i][i]) >= soma){
        contador_true++;
    }

  }

  if(contador_true < n){
        dominante(n, matriz);
  } else {
      return matriz;
  }
}
double GaussSeidel(int n, double m[][n+1],int max_inte, double erro_max) {
    int i, j, k, interacoes=0;
    double x[n], soma1, y[n], z[n], erro;

   VerificaDominancia(n,m);

        //PRIMEIRA INTERACAO
    for(i=1; i<n; i++)  {
        x[i] = 0;

                        }

        //N INTERACOES
    do  {
        if(interacoes > 0) {
            for(i=0; i<n; i++) {
            erro = fabs(y[i] - z[i]);  // max( |Xi(k+1)- Xi(k)| ) < ERRO MAXIMO
                if(erro < erro_max) {
                    printf("LIMITE DO ERRO ATINGIDO\n\n");

                    printf("A solucao eh:\n");
    for(i=0; i<n; i++){
        printf("X%d: %.5e \n", i, x[i]); //IMPRIME A SOLUCAO DO SISTEMA
    }

                    return 0;
                }
            }

        }

    for(i=0; i<n; i++)      {
    soma1 = 0;

                    z[i] = x[i];  // USADO PARA ARMAZENA O VETOR PARA CALCULO DO ERRO
        for(j=0; j<n ; j++){                    //O METODO DE GAUSS-SEIDEL OCORRE
            if(i != j)  {                       //NESSA PARTE DO CODIGO
            soma1 = soma1 + m[i][j]*x[j];
                        }
                            }
          x[i] = (m[i][n] - soma1)/m[i][i];
                    y[i] = x[i];   // USADO PARA ARMAZENA O VETOR ATUALIZADO PARA CALCULO DO ERRO
          }

     printf("\nInteracao %d \n", interacoes+1);
    for(i=0; i<n; i++){
        printf("\nX%d: %.5lf \n\n", i, x[i]); //QUANTIDADE DE INTERACOES
    }

        interacoes++;

    }while(interacoes < max_inte);

    printf("A solucao eh:\n");
    for(i=0; i<n; i++){
        printf("X%d: %.5e \n", i, x[i]); //IMPRIME A SOLUCAO DO SISTEMA
    }
    }

    int main(){

    int i, j, n/*TAMANHO DO SISTEMA*/;
        //TAMANHO DO SISTEMA

    printf("Digite a ordem do sistema(Com maximo 100):\n");
    scanf("%d", &n);
    printf("Digite os coeficientes:\n");

    double m[n][n+1]/*COEFICIENTES DO SISTEMA*/;

    while(n<1 || n>100) { // RESTRICAO DO SISTEMA PARA SER NO MAXIMO DE ORDEM 100
        printf("Valor invalido digite novamente:\n");
        scanf("%d", &n);
    }

    for(i=0; i<n; i++){
        for(j=0; j<n+1; j++) {
            printf("Elemento:(%d,%d): \n", i,j); //COEFICIENTES DAS VARIAVEIS DO SISTEMA
            scanf("%lf", &m[i][j]);
        }
    }


 GaussSeidel(n,m,20,0.00001); //maximainteração  0.00001 = minimo erro

        return 0;
    }