/*******************************************************
 *                     MP4.cpp                         *
 *******************************************************
 * Solving of multivariable equations using fractions. *
 * The coefficients for the equation will be read from *
 * the user defined file.                              *
 * The first number in the file is N, number of        *
 * variables, constrained 1<=N<=10                     *
 * It should be followed by the description of coef.   *
 * of the set of algebraic equations.                  *
 * The output solution to the system of equations      *
 * will be given in terms of fractions                 *
 *******************************************************
 * Written by: Olesia Kovalenko                        *
 * For:	       CS 107                                  *
 * Date:       2/17/2003                               *
 *******************************************************/ 



#include <iostream>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <fstream>

using namespace std;


//constants
const int DIM_ARRAY=100;


//definition of the class;
class Fraction
{
	public:
		//default constructor
		Fraction();
		
		//sets the fraction
		void setFrac(int valnum,int valden);
		
		//sets the numerator
		void setNumer(int numer);
		
		//returns numerator
		int getNum();
		
		//returns denominator
		int getDen();
		
		//displays fraction
		void dispFrac(int space1,int space2);
		
		//substraction
		void sub(Fraction frac1,Fraction frac2);
		
		// multiplication
		void mul(Fraction frac1,Fraction frac2);
		
		//division
		void div(Fraction frac1,Fraction frac2);
		
		//addition
		void add(Fraction frac1,Fraction frac2);
		
		//reduce the fraction
		void reduce();
		
		//returns double equivalent of the fraction
		double retdouble();		
	
	private:
		int num; //numerator
		int den; //denominator	

};


//function prototypes

//1. reads the data from the file.
int readarray(Fraction array[][DIM_ARRAY+1],char file[]) ;

//2. displays the equations.
void dispEq(Fraction array[][DIM_ARRAY+1],int n_of_var );

//3. finds maximum between two integers
int maximum(int num1,int num2);

//3a. uses function 3 with doubles
double maximum_double(double num1,double num2);
     
//4. displays a single equation 
void dispOneEq(Fraction array[DIM_ARRAY+1],int n_of_var );

//5. checks if the ith coeficient in ith row is zero
int checkIfZero(Fraction array[][DIM_ARRAY+1],int start_at_row,char file[30],int n_of_var );

//6. Performs the swap of two rows
void swap(Fraction array[][DIM_ARRAY+1],int old_row, int new_row, int n_of_var);

//7. displays the solution
void dispSoln(Fraction array[][DIM_ARRAY+1],int n_of_var);
  
//8. gets the maximum space needed to display the number in the collumn
void getspace(Fraction array[][DIM_ARRAY+1],int space1[DIM_ARRAY+1],int space2[DIM_ARRAY+1],int n_of_var);

//9. finds Greatest Common Denominator
int gcd(int num,int den);





int main()
{

cout<<endl<<"***********Olesia Kovalenko*******MP4***********"<<endl<<endl<<endl;
cout<<endl<<"***Solving multivariable algebraic Equations.***"<<endl<<endl<<endl;

//declare the variables:

//read file
char filenameR[30],sORc=0,junk=0;

//array
int N=0;
Fraction coefMatrix[DIM_ARRAY][DIM_ARRAY+1];

//ellimination
int newRow=0;
Fraction coef,mul_coef;

//request the filename containing the data;
cout<<"Please enter the filename to read the data: ";
cin >>filenameR;
cout<<endl;


//read in the equations and obtain the dimention of system.
N=readarray(coefMatrix,filenameR);


//display the equations.
cout<<"The system of Linear Algebraic Equations is as follows: "<<endl<<endl;
dispEq(coefMatrix,N);


//Prompt the user for the step or continious mode
cout<<"Would you like the program to run in a step or a continious mode (s/c)"<<endl;
cout<<"Please make your selection now: ";
cin>>sORc;


//absorb the rest of the input
while (junk !='\n')
{
	cin.get(junk);	
}   

junk=0;	 	 
//loop untill the correct input is entered
while(sORc!='s' && sORc!='c' && sORc!='S' && sORc!='C')
{
	cout<<endl<<endl<<"ERROR: Incorrect input! "<<endl
		<<"Your selection should be \'s\' for step mode or \'c\' for continous"<<endl
		<<"Please re-enter your selection, now: ";
	cin>>sORc;
	while (junk !='\n')
	{
		cin.get(junk);	
	}   
junk=0;
}


//Notify the user of the selection made:
cout<<endl<<"You have chosen to run the program in :"<<endl;
if(sORc=='s' || sORc=='S')
{
	cout<<"Step mode; The equations will be reprinted every time the swap,"<<endl
	    <<"or zeroing-out of variables in equations is performed."<<endl<<endl;
}
else
{
	cout<<"Continious mode; No intermediate steps will be printed."<<endl<<endl;
}

//Gauss-Jordan reduction
for (int row=0;row<N; row++)
{
	cout<<"Currently processing the row: "<<row+1<<endl<<endl;
	//check if the ith coefficient in ith row is zero
	newRow=checkIfZero(coefMatrix,row,filenameR,N);
	
	//if the coefficient was zero swap the current row with the one returned
	if (newRow!=0)
	{
 		cout<<"Coefficient in the position # "<<row+1<<" in the row # "<<row+1<<" is zero"<<endl;
 		cout<<"The swap operation with the row "<<newRow+1<<" is performed."<<endl;
 		cout<<endl;
 		
		swap(coefMatrix,row,newRow,N);
	
		//in step mode print the equations
		if(sORc=='s' || sORc=='S')
		{
			cout<<endl<<"After swap the system is: "<<endl;
			dispEq(coefMatrix,N);
		}
	}
	
	//divide the whole row by the ith coefficient
	coef=coefMatrix[row][row];


	for(int col=0;col<N+1;col++)
	{	
		coefMatrix[row][col].div(coefMatrix[row][col],coef);
	}
	
	//zero out the coefficients in other rows 
	for(int rows=0;rows<N;rows++)
	{
		//perform zeroing only on other than current row
		if (rows!=row)
		{	
			//set the coeficient to the current zeroing coefficient
			coef=coefMatrix[rows][row];
			for(int cols=0;cols<N+1;cols++)
			{
				mul_coef.mul(coef,coefMatrix[row][cols]);
				coefMatrix[rows][cols].sub(coefMatrix[rows][cols],mul_coef);				
			}
		}	

	}
	
	//in step mode print the equations
	if(sORc=='s' || sORc=='S')
	{	
		cout<<endl<<"After the Zeroing out, the system of equations is as follows: "<<endl;	
		dispEq(coefMatrix,N); 
	}

}

//display the solution
cout<<endl;
dispSoln(coefMatrix,N);



cout<<endl<<"********************THE END*********************"<<endl<<endl<<endl;

return 0;

}

//////////////////////////////////////////////////////////////////
// functions defined:                                           //
//////////////////////////////////////////////////////////////////

//////////////      
// 1. reads in the equations and checks for errors such as non-int values, and the wrong size of the array
//	inputs:  int 2-D array, where the data will be evantually read into,name of the file.
//	outputs: number of variables in the equation, filled array 
////////////// 		
	
int readarray(Fraction array[][DIM_ARRAY+1],char file[]) 
{ 
	//local variables:
	
	//to operate file
	ifstream infile;
	//to read in the value
	int junk_int=0; 
	double junk=0;
	//for use of sizing 	
	int n_of_var=0,row=0,col=0,last_read=0;
	

	//open the file.
	infile.open(file);

	//check for the error on opening
	if (!infile.is_open())
	{	
		cout<<"ERROR: Cannot access the \""<<file<<"\" file. Aborting the program."<<endl<<endl;
		exit(1);
	}

	// check if the first number is an integer
	infile >> junk;
	junk_int=static_cast<int>(junk);
	if(junk-junk_int !=0)
	{
		cout<<"ERROR: In the \""<<file<<"\" file. "<<endl;
		cout<<"The first number in the file indicating the dimension of the system "<<endl;
		cout<<"must be an integer! "<<endl;
		cout<<"Aborting the Program."<<endl<<endl;
		infile.close();
		exit(1);
	}
	
	n_of_var=junk_int;

	// check if it is between 1 and 10
	if (n_of_var<1 || n_of_var>10)
	{
		cout<<"ERROR: In the \""<<file<<"\" file. "<<endl;
		cout<<"The first number in the file is indicating the dimension of the system.  "<<endl;
		cout<<"Must be numeric integer constrained between 1 and 10 including! "<<endl;
		cout<<"Aborting the Program."<<endl<<endl;
		infile.close();
		exit(1);
	}

	// read in the equations and check for dimension and integers errors
	while(infile>>junk)
	{

		// check if integer
		junk_int=static_cast<int>(junk);
		if(junk-junk_int !=0)
		{
			cout<<"ERROR: In the \""<<file<<"\" file. "<<endl;
			cout<<"All the coefficients of the system must be integers! "<<endl;
			cout<<"Aborting the Program."<<endl<<endl;
			infile.close();
			exit(1);
		}	

		//read the value into array
		array[row][col].setNumer(junk); 
		
		//update the position
		if (col<n_of_var)
		{
			col++;
		}
		else 
		{
			col=0;
			row++;
		}
		
		
		last_read++;
	}
	
	//check for other arrors, attemped to overfill, underfill, non-numeric
	if (last_read>(n_of_var*(n_of_var+1)))
	{
		cout<<"ERROR: In the \""<<file<<"\" file. "<<endl;
		cout<<"There are more coefficients in the file than needed for specified dimension! "<<endl;
		cout<<"Aborting the Program."<<endl<<endl;
		infile.close();	
		exit(1);
	}
	else if(last_read<(n_of_var*(n_of_var+1)))
	{
		cout<<"ERROR: In the \""<<file<<"\" file. "<<endl;
		cout<<"There are not enough integer coefficients in the file for specified dimension! "<<endl;
		cout<<"Or,you might have non-numeric coefficients present!"<<endl;
		cout<<"Aborting the Program."<<endl<<endl;
		infile.close();
		exit(1);
	}
	
	//close the file after reading
	infile.close();	
	
	
	return(n_of_var);		

}

//////////
// 2. The function for displaying the set of the equations.
//        inputs:  the array of class fraction containing coeficients of the equations, number of variables present
//	 outputs:  none, the equations will be displayed
//////////
void dispEq(Fraction array[][DIM_ARRAY+1],int n_of_var )
 {
 
 	//local variables
 	char var_name[DIM_ARRAY];
 	char var='a';
 	int spaceNum[DIM_ARRAY+1],spaceDen[DIM_ARRAY+1];
 	int clm2=0;
 	
 	
 	//generate an array of variable names
 	for (int i=0; i<n_of_var;i++)
 	{	
 		var_name[i]=var;
 		var++;
 	}
 
	//get space needed
	getspace(array,spaceNum,spaceDen,n_of_var);
 	
 	
 	
 	//display the equations

 	for (int rw=0; rw<n_of_var; rw++)
 	{	
 		for(int clm=0; clm<n_of_var-1; clm++)
 		{
 			array[rw][clm2].dispFrac(spaceNum[clm2],spaceDen[clm2]);
 			cout<<var_name[clm2]<<" + ";
 			clm2++;
 		}
 			array[rw][clm2].dispFrac(spaceNum[clm2],spaceDen[clm2]);
 			cout<<var_name[clm2]<<" = ";
 		    	array[rw][clm2+1].dispFrac(spaceNum[clm2+1],spaceDen[clm2+1]);
 		    	cout<<endl;
 		clm2=0;		 	
 	}
 	cout<<endl;
 	
 }
 
 ////////////
 // 3. The function finds the maximum between two numbers
 //	 inputs: two integers
 //	 output: maximum integer
 ///////////
 int maximum(int num1,int num2)
 {
 	if(num2>num1)
 	{
 		return(num2);
 	}
 	else
 	{
 		return(num1);
 	}
 } 
 
 ///////////
 // 3a. The function finds the maximum between two numbers.
 //      overloading of the one above
 //	 inputs: two doubles
 //	 output: maximum double
 ///////////
 double maximum_double(double num1,double num2)
 {
 	if(num2>num1)
 	{
 		return(num2);
 	}
 	else
 	{
 		return(num1);
 	}
 } 
 

 ////////////
 // 4. Displays a single equation
 // Inputs: 1D array representing equation, #of variables
 // Outputs: None, the equation is displayed
 ////////////
 void dispOneEq(Fraction array[DIM_ARRAY+1],int n_of_var )
 {
 
 	//local variables
 	char var_name[DIM_ARRAY];
 	char var='a';
 	int clm2=0;
 	
 	//generate an array of variable names
 	for (int i=0; i<n_of_var;i++)
 	{	
 		var_name[i]=var;
 		var++;
 	}
 	
 	//display the equations
 	for(int clm=0; clm<n_of_var-1; clm++)
 	{
 		cout<<array[clm2].getNum();
 		//display denominator only if it is not one
 		if (array[clm2].getDen()!=1)
 		{
 			cout<<'/'<<array[clm2].getDen();
 		}
 		cout<<var_name[clm2]<<" + ";
 		clm2++;
 	}
 	cout<<array[clm2].getNum();
 	if (array[clm2].getDen()!=1)
 	{
 		cout<<'/'<<array[clm2].getDen();
 	}
 	cout<<var_name[clm2]<<" = ";
 	cout<<array[clm2+1].getNum();
 	if (array[clm2].getDen()!=1)
 	{
 		cout<<'/'<<array[clm2+1].getDen();
 	}
 	
 	cout<<endl;

 }


 ///////////
 // 5. The function will check if the coef in the ith row in the ith position is zero.
 //    If it is returns a row that contains a coefficient with absolute maximum in this position
 //     Inputs: 2D array of, int # of the row that is being checked, name of file, # of variables.
 //     Outputs: the # of the row the current row can be swaped with,
 //              or displays error and quit.   
 ///////////	
 int checkIfZero(Fraction array[][DIM_ARRAY+1],int start_at_row,char file[30],int n_of_var )
 {
 	//local variables
 	double absmax=0,absmax_old=0;
 	int maxpos=0;
	Fraction wrongEq[DIM_ARRAY+1];
	
	if(array[start_at_row][start_at_row].retdouble()==0)
	{
		//find the abs max in other rows;
		for(int next=start_at_row+1;next<n_of_var ;next++)
		{
			absmax_old=absmax;
			absmax=maximum_double(absmax, abs(array[next][start_at_row].retdouble()));
			if(absmax_old<absmax)
			{
				maxpos=next;
			}			
		}
		//if none found check if the result of this row is zero and print the errors
		if(maxpos==0)
		{
			// create the vector consisting of only the
			// ith equation that has a zero coef in ith position 
			for(int i=0;i<n_of_var+1;i++)
			{
				wrongEq[i]=array[start_at_row][i];
			}
			
			// display error
			cout<<endl<<"ERROR: In file \""<<file<<"\"!"<<endl;
			cout<<"The error is in the following equation:"<<endl;
	
			// disp the equation were the error occured;
			dispOneEq(wrongEq,n_of_var);
			
			// state the type of error.
			if(array[start_at_row][n_of_var].retdouble()==0)
			{
				cout<<"The system of equations has more than one solution!"<<endl;
			}
			else if(array[start_at_row][n_of_var].retdouble()!=0)
			{
				cout<<"The system of equations does not have a unique solution!"<<endl;
			}	
			cout<<"Aborting the Program."<<endl<<endl;
			exit(1);
		}	
	}
	
	return(maxpos);
 
 }	
 
 ///////////
 // 6. The function will swap two rows.
 //     Inputs: The 2d array, and the numbers of the rows to be swaped, # of variables.
 //     Outputs: none, the rows are exchanged, the message along with the equations displayed. 
 ///////////
 void swap(Fraction array[][DIM_ARRAY+1],int old_row, int new_row, int n_of_var)
 {
 	//local variables
 	Fraction tempArray[DIM_ARRAY+1];
 	
 	// store the old_row into temporary array
 	for (int i=0;i<n_of_var+1;i++)
 	{
 		tempArray[i]=array[old_row][i];
 	} 
 	
 	// perform the swap
 	for (int j=0; j<n_of_var+1;j++)
 	{
 		array[old_row][j]=array[new_row][j];
 		array[new_row][j]=tempArray[j]; 		
 	} 
 }
 
 ///////////
 // 7. The function for display of the solution
 //     Input: 2D array of coefficients, number of variables
 //     Output: none, displays the solution
 ///////////
 void dispSoln(Fraction array[][DIM_ARRAY+1],int n_of_var)
 {
 	//local variables
 	char var_name[DIM_ARRAY];
 	char var='a';
 	Fraction soln[DIM_ARRAY];
 	int maxspaceNum=0,maxspaceDen=0;
 	int flagNeg=0,powOf10=1;
 	
 	//generate an array of variable names
 	for (int i=0; i<n_of_var;i++)
 	{	
 		var_name[i]=var;
 		var++;
 	}
 	
 	//store the result in the solution array
 	for(int j=0;j<n_of_var;j++)
 	{
 		soln[j]=array[j][n_of_var];		
 	}
 	
 	//find the space needed to display the maximum result
 	//find the maximum space needed to display the numerator
 	for (int row=0; row<n_of_var; row++)
 	{
	 	if ((soln[row].getNum())<0)
	 	{
	 		flagNeg=1;
	 		while (soln[row].getNum()/pow(10.0,powOf10) <= -1)
	 		{
	 			powOf10++;
	 		}
	 	
	 	}
	 	else
	 	{
	 		while (soln[row].getNum()/pow(10.0,powOf10) >= 1)
	 		{
	 			powOf10++;
	 		}
  		}
  		maxspaceNum=maximum(maxspaceNum,powOf10+flagNeg);
  		flagNeg=0;
	} 
 	powOf10=1;	

 	//find the maximum space needed to display the denumerator
	 for (int rownext=0; rownext<n_of_var; rownext++)
 	{
	 	if ((soln[rownext].getNum())<0)
	 	{
	 		flagNeg=1;
	 		while (soln[rownext].getDen()/pow(10.0,powOf10) <= -1)
	 		{
	 			powOf10++;
	 		}
	 	
	 	}
	 	else
	 	{
	 		while (soln[rownext].getDen()/pow(10.0,powOf10) >= 1)
	 		{
	 			powOf10++;
	 		}
  		}
  		maxspaceDen=maximum(maxspaceDen,powOf10+flagNeg);
  		flagNeg=0;
	} 
 	
 	//display the solution
 	cout<<"The solution of this system of equations is as follows:"<<endl;
 	for(int ii=0;ii<n_of_var;ii++)
 	{
 		cout<<var_name[ii]<<" = ";
 		soln[ii].dispFrac(maxspaceNum,maxspaceDen);
		cout<<endl;
 	}
 } 
 
 
 
 ///////////
 // 8. The function will get space needed to display the number
 //	Inputs:  2D array of coefficients, two empty 1D array to store the space needed 
 //              for each collumn,the number of variables.
 //     Outputs: fills up the space arrays.
 ///////////
 void getspace(Fraction array[][DIM_ARRAY+1],int space1[DIM_ARRAY+1],int space2[DIM_ARRAY+1],int n_of_var)
 {
 
 //local variables
 int max[DIM_ARRAY+1];
 int powOf10=1,flagNeg=0;
 //calculate the size of space needed in each column
	//initilize array of max coef to -100
	for (int j=0; j<n_of_var+1;j++)
	{
		max[j]=-100;
	}
	
	// for each collumn find the maximum space needed to display the numerator and store it in the array
	for (int col=0; col<n_of_var+1; col++)
	{ 
 		for (int row=0; row<n_of_var; row++)
 		{
	 		if ((array[row][col].getNum())<0)
	 		{
	 			flagNeg=1;
	 			while (array[row][col].getNum()/pow(10.0,powOf10) <= -1)
	 			{
	 				powOf10++;
	 			}
	 		
	 		}
	 		else
	 		{
	 			while (array[row][col].getNum()/pow(10.0,powOf10) >= 1)
	 			{
	 				powOf10++;
	 			}
  			}
  			max[col]=maximum(max[col],powOf10+flagNeg);
  			flagNeg=0;
		} 
		space1[col]=max[col];
		powOf10=1;	
 	}
 		
 
 	//re-initilize array of max coef to -100
	for (int jj=0; jj<n_of_var+1;jj++)
	{
		max[jj]=-100;
	}
	
 	// for each collumn find the maximum space needed to display the denumerator
	for (int cols=0; cols<n_of_var+1; cols++)
	{ 
 		for (int rows=0; rows<n_of_var; rows++)
 		{
	 		if ((array[rows][cols].getDen())<0)
	 		{
	 			flagNeg=1;
	 			while (array[rows][cols].getDen()/pow(10.0,powOf10) <= -1)
	 			{
	 				powOf10++;
	 			}
	 		
	 		}
	 		else
	 		{
	 			while (array[rows][cols].getDen()/pow(10.0,powOf10) >= 1)
	 			{
	 				powOf10++;
	 			}
  			}
  			max[cols]=maximum(max[cols],powOf10+flagNeg);
  			flagNeg=0;
		} 
		space2[cols]=max[cols];
		powOf10=1;	
 	}

 }

 
 ///////////
 // 9. The function will find the greatest Common Denominator between two numbers
 //	Inputs: two integers
 //	Outputs: GCD
 ///////////
int gcd(int num,int den)
{
	//local variables
	int nm1,nm2,rem;
	
	//first check if num or den !=0, if it is gcd is zero
	if (num==0 ||den==0)
	{
		return(0);
	}
			 
	//find the biggest between numerator and denominator			
	if (num>=den)
	{
		nm1=num;
		nm2=den;
	}
	else		
	{
		nm1=den;
		nm2=num;
	}
		
			
			
	//compute the GCD
	rem = nm1%nm2;
	while(rem!=0)
	{
		nm1=nm2;
		nm2=rem;
		rem=nm1%nm2;
	}
	return(nm2);
			
}

			
 
 
 
 
//////////////////////////////////////////////////////////////////////////////////////
// member functions of class Fraction definitions                                   //
//////////////////////////////////////////////////////////////////////////////////////
 
//1. default constructor
Fraction:: Fraction()
{
	num=0;
	den=1;
}
		
//2. sets the values of the fraction
//	Inputs: values for numerator and denominator
//	Outputs: none
void Fraction:: setFrac(int valnum,int valden) 
{	
	num=valnum;
	den=valden;
}

//3. sets the numerator of the fraction
//	Inputs: value for numerator 
//	Outputs: none
void Fraction:: setNumer(int numer)
{
	num=numer;	
}
		
//4. accesses the numerator
//	Inputs: none
//	Outputs: numerator
int Fraction::  getNum()
{
	return(num);
}
		
//5. accesses the denominator
//	Inputs: none
//	Outputs: denominator
int Fraction::  getDen()
{
	return(den);
}
		
  
//6. display fraction
//	Inputs: maximum space in column for num. and denominator
//	Outputs: none, prints fraction.
void Fraction:: dispFrac(int space1,int space2)
{
	if(den==1)
	{
		cout<<setw(space1+space2+1)<<num;
	}
	else 	
	{	
		cout<<setw(space1)<<num;
		cout<<'/'<<setw(space2)<<den;

	}
	
}
		
//7. substract two fractions
//	Inputs: two fractions
//	Outputs: fraction after operation is performed
void Fraction:: sub(Fraction frac1,Fraction frac2)
{
	int hcf=gcd(frac1.den,frac2.den);

	num=(frac1.num*(frac2.den/hcf)) - (frac2.num*(frac1.den/hcf));
	den=hcf*(frac1.den/hcf)*(frac2.den/hcf);
	reduce();
			
}

		
		
//8. multiply fractions 
//	Inputs: two fraction
//	Output: fraction after operation and reduction is performed
void Fraction:: mul(Fraction frac1,Fraction frac2)
{
	
	num=frac1.num*frac2.num;
	den=frac1.den*frac2.den;
	reduce();
}	
		
//9. division of fractions 
//	Inputs: two fraction
//	Output: fraction after operation and reduction is performed
void Fraction:: div(Fraction frac1,Fraction frac2)
{
	//NOTE: if that does not work the overflow can be prevented by building a new class 
	// to represent an integer, the class will contain the following members:
	// sign, exponent and matissa. It was not required in the program and thus is not 
	// implemented, because of the lack of time.
	//to reduce the numbers to prevent overflow or 
	//reduce the possibility of such.
	//store the numerators into fraction, reduce the fraction set numerators back
	Fraction numers, denoms;
	numers.setFrac(frac1.num,frac2.num);
	numers.reduce();
	frac1.num=numers.num;
	frac2.num=numers.den;
	
	//store the denominators into fraction, reduce the fraction set denominators back
	denoms.setFrac(frac1.den,frac2.den);
	denoms.reduce();
	frac1.den=denoms.num;
	frac2.den=denoms.den;
	
		
	//proceed with the multiplication
	num=frac1.num*frac2.den;
	den=frac1.den*frac2.num;
	reduce();
}	
	

//10. addition of two fractions
//	Inputs: two fractions
//	Outputs: fraction after operation and reduction is performed
void Fraction:: add(Fraction frac1,Fraction frac2)
{
	int hcf=gcd(frac1.den,frac2.den);

	num=(frac1.num*(frac2.den/hcf)) + (frac2.num*(frac1.den/hcf));
	den=hcf*(frac1.den/hcf)*(frac2.den/hcf);
	reduce();
			
}
		
		
//11. reduces fraction
//	Inputs: none
//	Outputs: none, fraction reduced
void Fraction:: reduce()
{
	//local variables
	int divisor;
	if(den==0)
	{
		cout<<"ERROR! Division by zero!"<<endl;
		cout<<"Aborting the program"<<endl;
		exit(1);
	}	
			
	//obtain the GCD
			
			
	while( gcd(abs(num),abs(den))>1)
	{
		divisor=gcd(abs(num),abs(den));
		num=num/ divisor;
		den=den/ divisor;
	}
	// check if the denominator smaller than zero and if it is 
	//multiply the numerator by -1
	if(den<0)
	{
		num=-1*num;
		den=-1*den;
	}
	
	//check if the num equals to zero, that is the fruction is a zero fraction
	//if it is set numerator==1 
	if(num==0)
	{
		den=1;
	}
		
}
//12. returns double equivalent of the fraction
//	Inputs: none
//	Outputs: fractions value as a double
double Fraction:: retdouble()
{
	double value=static_cast<double>(num)/den;
	return(value);
}