#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 ]){                       //ESSA É A 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) {    // ESSA FOI A FUNÇÃO Q VC CRIOU, SÓ Q EM UMA FUNÇÃO   ¯\_(?)_/¯
    int i,j,contador,cont_erro;
    double konst,x[n],y[n], mat_aux[n][n+1];          // DECLARO UM VETOR DE INCOGNITAS, UM VETOR Q O VAI AUXILIAR, UMA MATRIZ CÓPIA DA MATRIZ INFORMADA


   VerificaDominancia(n,m);

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

                        }

        //N INTERACOES
    do{

            cont_erro = 0;

            printf("\n\ninteracao no %i\t",contador);
            for(i=0;i<n;i++){
            printf(" \tx(%i) = %.4lf\t",i+1,x[i]);
            }

    for(i=0;i<n;i++){
        konst = 0.0;
        for(j=0;j<n;j++){
            if(i != j){
                konst = konst + x[j]*mat_aux[i][j];
            }
        }
        x[i] = (mat_aux[i][n] - konst)/mat_aux[i][i];
    }

    for(i=0;i<n;i++){
               if(fabs(x[i]-y[i]) < erro_max){
                    cont_erro++;
                }
                y[i] = x[i];
        }

    contador++;
    if(contador == max_inte){
        printf("\n\n\n\n\n\n\t\t\t\t**Maxima interacao atingida!**\n");
        break;
    }
 }while(cont_erro != n);

    printf("A solucao eh:\n");
    for(i=0; i<n; i++){
        printf("%.3lf \n", x[i]);
    }
    }

    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+1,j+1);
            scanf("%lf", &m[i][j]);
        }
    }


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

        return 0;
    }