//---------------------------------------------------------------------------

#include <iostream>
#include <math.h>
#include <fstream>
#include <string>
#include <stdlib.h>

using namespace std;

//---------------------------------------------------------------------------

#define typ double		//w drugiej wersji testow – typ float
#define MAXN 101
int n;
typ epsilon;
int MLI;
typ Alfa[MAXN][MAXN];
typ Beta[MAXN];
typ A[MAXN][MAXN];
typ B[MAXN];
typ x_poprzedni[MAXN];
typ x_aktualny[MAXN];
typ Xk1[MAXN];
typ Xk[MAXN];
int iter=0;

//---------------------------------------------------------------------------

int funkcja_a()
{
 	int i,j;
	char nazwaPliku[64];

cout << "Podaj n: ";         			//czytanie z klawiatury: n, epsilon i MLI
cin >> n;
cout << "Podaj epsilon: ";
cin >> epsilon;
cout << "Podaj MLI: ";
cin >> MLI;
cout << "Podaj nazwe pliku wejsciowego: ";
	cin >> nazwaPliku;                            //pobranie nazwy pliku z klawiatury

	ifstream plik(nazwaPliku);

	if(! plik.is_open())	//sprawdzenie, czy plik o podanej nazwie moze zostac wykorzystany
		return 0;		//funkcja zwraca zero jezeli jest to niemozliwe

	for(i = 1; i <= n; i++)				//wczytanie macierzy A z pliku
		for(j = 1; j <= n; j++)
			plik >> A[i][j];

	for(i = 1; i <= n; i++)				//wczytanie wektora B z pliku
        	plik >> B[i];

	plik.close();              //zamkniecie pliku
	return 1;                  //funkcja zwraca 1 jezeli plik został poprawnie wykorzystany
}

//---------------------------------------------------------------------

int funkcja_b()
{
	for(int i=1;i<n+1;i++)
	{
		if(A[i][i]!=0)
		{
			Beta[i]=B[i]/A[i][i];              	//obliczanie wartosci macierzy Beta
			for(int j=1;j<n+1;j++)
			{
				if(i==j) Alfa[i][j]=0;     	//obliczanie wartosci macierzy Alfa
				else Alfa[i][j]=-(A[i][j]/A[i][i]);
			}

		}
		else return 0;					//funkcja zwraca zero jezeli niemożliwe
//jest obliczenie macierzy Alfa i Beta
	}
	return 1;		//funkcja zwraca 1 jezeli obliczenie macierzy Alfa i Beta byly mozliwe
}

//---------------------------------------------------------------------

void funkcja_c()
{
	for(int i=1;i<n+1;i++)
		x_aktualny[i]=Beta[i];

	typ norma=0.0;
	typ suma=0.0;
typ pom=0.0;

	do
	{
		for(int i=1;i<n+1;i++) 			// przepisanie aktualnego wektora rozwiązań
			x_poprzedni[i]=x_aktualny[i]; 	// jako rozwiązanie poprzednie

		iter++; 					//inkrementacja licznika iteracji

           	for(int i=1;i<n+1;i++)			//wyznaczanie aktualnego wektora
		{
			pom=0.0;
                        for(int j=1;j<n+1;j++)
				if(j!=i)
					pom+=(Alfa[i][j]*x_poprzedni[j]);
			x_aktualny[i]=pom+Beta[i];
		}

		//obliczanie normy

		suma=0;
		for(int i=1;i<n+1;i++)
			suma+=((x_aktualny[i]-x_poprzedni[i])*(x_aktualny[i]-x_poprzedni[i]));
		norma=sqrt(suma/n);
	}
	while((iter<MLI)&&(norma>epsilon));
}

//---------------------------------------------------------------------

int funkcja_d(bool zm)
{
char raport[64];
cout << "Podaj nazwe pliku zawierajacego raport: ";
cin >> raport;
ofstream plik(raport);

if(! plik.is_open())		//sprawdzenie, czy plik o podanej nazwie zostal utworzony
		return 0;			//funkcja zwraca zero jezeli jest to niemozliwe
	plik<<"Macierz A:"<<endl;		//wpisanie macierzy A do pliku zawierającego raport
	for(int i=1;i<n+1;i++)
        	{
              	for(int j=1;j<n+1;j++)
        		plik<<"\t"<<A[i][j];
              	plik<<endl;
        	}
	plik<<endl;
	plik<<"Wektor B:"<<endl;        //wpisanie wektora B do pliku zawierającego raport

	for(int i=1;i<n+1;i++)
		plik<<"\t"<<B[i];

	plik<<endl<<endl;
	plik<<"epsilon = "<<epsilon<<endl;
	plik<<"MLI = "<<MLI<<endl;

	if(zm==true)     //sprawdzenie czy dla podanych danych można skorzystac z metody Jakobiego
	{
		plik<<"\nMacierz Alfa:"<<endl;	//wpisanie macierzy Alfa do pliku zawier. raport
        	for(int i=1;i<n+1;i++)
        		{
              		for(int j=1;j<n+1;j++)
        			plik<<"\t"<<Alfa[i][j];
              		plik<<endl;
        		}

        	plik<<"\nWektor Beta:"<<endl;	//wpisanie wektora Beta do pliku zawier. raport

        	for(int i=1;i<n+1;i++)
        		plik<<"\t"<<Beta[i];

        	plik.precision(20);
        	plik<<"\n\nLiczba wykonanych iteracji wynosi "<<iter<<endl;
        	plik.setf(ios::scientific,ios::floatfield);	//zmiana trybu wyswietlania liczb

        	plik<<"\n\nWektor ostatnio wykonanej iteracji:"<<endl;
        	for(int k=1;k<n+1;k++)
        		plik<<"\t"<<x_aktualny[k]<<endl;

        	plik<<"\n\nWektor przedostatnio wykonanej iteracji:"<<endl;
        	for(int k=1;k<n+1;k++)
        		plik<<"\t"<<x_poprzedni[k]<<endl;
	}
	else plik<<"\n\nDla podanych danych niemozliwe jest obliczenie rozwiazania metoda Jacobiego.";

	plik.close();
}

//---------------------------------------------------------------------

int main(int argc, char* argv[])
{
	bool zm=false;
	if(funkcja_a()==1)
	{
		if(funkcja_b()==1)
		{
			funkcja_c();
			zm=true;
		}
		funkcja_d(zm);
	}
	else cout<<"Plik o podanej nazwie nie moze zostac wykorzystany w programie."<<endl;

	system("PAUSE");
	return 0;
}

//---------------------------------------------------------------------------