/*
	Matthew Giampiccolo
			&
	Jason M. Snouffer

	Computer Science & Programming 
	Wednesday, October 30, 2002

	Lab 9 Problem 2 & Extra Credit

	This program utilizes various functions from a programmer-developed library of fraction 
	manipulation functions. The program recieves two fractions from the user, along with an
	arithmetic operator, performs desired arithmetic operation, and then outputs the simplified
	fractional result.


	Test Suite:
	(Note: The slash is not entered by the user.)

	Input (Fraction 1): 1/10
	Inpuut (arithmetic operator): +
	Input (Fraction 2): 9/11
	Output: 1/10 + 9/11 = 101/110
	
	Input (Fraction 1): 9/20
	Inpuut (arithmetic operator): +
	Input (Fraction 2): -10/-25
	Output: 9/20 + -10/-25 = 17/20

	Input (Fraction 1): 5/6
	Inpuut (arithmetic operator): +
	Input (Fraction 2): 2/33
	Output: 5/6 + 2/33 = 59/66

	Input (Fraction 1): -5/16
	Inpuut (arithmetic operator): +
	Input (Fraction 2): 98/105
	Output: -5/16 + 98/105 = 149/240

	Input (Fraction 1): 3/7
	Inpuut (arithmetic operator): +
	Input (Fraction 2): 2/1001
	Output: 3/7 + 2/1001 = 431/1001

	Input (Fraction 1): 8/11
	Inpuut (arithmetic operator): -
	Input (Fraction 2): 20/30
	Output: 8/11 - 20/30 = 2/33

	Input (Fraction 1): 7/23
	Inpuut (arithmetic operator): -
	Input (Fraction 2): 56/20
	Output: 7/23 - 56/20 = -287/115

	Input (Fraction 1): 0/5
	Inpuut (arithmetic operator): -
	Input (Fraction 2, numerator): 5
	Input (Fraction 2, denominator): 0
	Output: Please enter a nonzero denominator: 
	Input (Fraction 2, denominator): 6
	Output: 0/5 - 5/6 = -5/6

	Input (Fraction 1): 78/97
	Inpuut (arithmetic operator): -
	Input (Fraction 2): 42/42
	Output: 78/97 - 42/42 = -19/97

	Input (Fraction 1): 532/896
	Inpuut (arithmetic operator): -
	Input (Fraction 2): 546/874
	Output: 532/896 - 546/874 = 53/736

	Input (Fraction 1): 1/3
	Inpuut (arithmetic operator): *
	Input (Fraction 2): 5/11
	Output: 1/3 * 5/11 = 5/33

	Input (Fraction 1): 8/90
	Inpuut (arithmetic operator): *
	Input (Fraction 2): 7/62
	Output: 8/90 * 7/62 = 14/1395

	Input (Fraction 1): 5/63
	Inpuut (arithmetic operator): *
	Input (Fraction 2): 785/96
	Output: 5/63 * 785/96 = 3925/6048

	Input (Fraction 1): 75/98
	Inpuut (arithmetic operator): *
	Input (Fraction 2): 89/98
	Output: 75/98 * 89/98 = 6675/9604

	Input (Fraction 1): 0/10
	Inpuut (arithmetic operator): *
	Input (Fraction 2): 5/5
	Output: 0/10 * 5/5 = 0/1

	Input (Fraction 1): 5/6
	Inpuut (arithmetic operator): /
	Input (Fraction 2): 4/5
	Output: 5/6 / 4/5 = 25/24

	Input (Fraction 1): 8/90
	Inpuut (arithmetic operator): /
	Input (Fraction 2): 96/4
	Output: 8/90 / 96/4 = 1/270

	Input (Fraction 1): -89/40
	Inpuut (arithmetic operator): /
	Input (Fraction 2): 89/40
	Output: -89/40 / 89/40 = -1/1

	Input (Fraction 1): 32/60
	Inpuut (arithmetic operator): /
	Input (Fraction 2): 65/66
	Output: 32/60 / 65/66 = 176/325


	All of the sample inputs within this test suite were tested and performed as expected.
*/



#include<iostream>
#include<cstdlib>

using namespace std;

/******************************Start of Function Prototypes*************************************/


/*
The function reads from the user the numerator and denominator of a fraction, insisting that the 
denominator not be 0.

preconditions: none

postconditions: recieves two integers from user, ensures that the second int is nonzero, and 
modifies arguments that are referenced by the function's 2 pass-by-reference varaiables.
*/
void get_fraction (int & numerator, int & denominator);


/*
The function displays the numerator and denominator of a fraction, with a '/' in between them.

preconditions: denominator must be nonzero

postconditions: prints value of first argument, a slash, and the value of the second argument.
*/
void display_fraction (int numerator, int denominator); 


/*
The function simplifies the input fraction and returns to its caller with the corresponding 
values of numerator and denominator.

preconditions: denominator must be nonzero

postconditions: modifies pass-by-reference variables
*/
void simplify_fraction (int & numerator, int & denominator);


/*
The function requests and validates a arithmetic operation symbol from the user

preconditions: none

postconditions: returns a character which represents an arithmetic operator
*/
char get_arithmetic_operator(void);


/*
This function performs addition between two fractions

preconditions: both denominators must be nonzero

postconditions: modifies the two pass-by-reference variables to the unsimplified values of the resulting
numerator and denominator
*/
void do_fraction_addition (int numerator1, int denominator1, int numerator2, int denominator2, 
						   int& resulting_numerator, int& resulting_denominator);


/*
This function performs subtraction between two fractions

preconditions: both denominators must be nonzero

postconditions: modifies the two pass-by-reference variables to the unsimplified values of the resulting
numerator and denominator
*/
void do_fraction_subtraction (int numerator1, int denominator1, int numerator2, int denominator2, 
						      int& resulting_numerator, int& resulting_denominator);


/*
This function performs multiplication between two fractions

preconditions: both denominators must be nonzero

postconditions: modifies the two pass-by-reference variables to the unsimplified values of the resulting
numerator and denominator
*/
void do_fraction_multiplication (int numerator1, int denominator1, int numerator2, int denominator2, 
								 int& resulting_numerator, int& resulting_denominator);


/*
This function performs division between two fractions

preconditions: both denominators and numerator2 must be nonzero

postconditions: modifies the two pass-by-reference variables to the unsimplified values of the resulting
numerator and denominator
*/
void do_fraction_division (int numerator1, int denominator1, int numerator2, int denominator2, 
						   int& resulting_numerator, int& resulting_denominator);


/*************************************Start of int main()********************************************/

int main ()
{
	int numerator1, denominator1, numerator2, denominator2, numerator_final, denominator_final;
	char arithmetic_operator;
	

	get_fraction (numerator1, denominator1);
	
	arithmetic_operator = get_arithmetic_operator();
	
	get_fraction (numerator2, denominator2);
	

	if (arithmetic_operator == '+')
	{
		do_fraction_addition (numerator1, denominator1, numerator2, denominator2, 
							  numerator_final, denominator_final);
	}
	

	else if (arithmetic_operator == '-')
	{
		do_fraction_subtraction (numerator1, denominator1, numerator2, denominator2, 
								 numerator_final, denominator_final);
	}
	

	else if (arithmetic_operator == '*')
	{
		do_fraction_multiplication (numerator1, denominator1, numerator2, denominator2, 
									numerator_final, denominator_final);
	}
	

	else	/*	Note: because of get_arithmetic_operator(), this else will only run when
				arithmetic_operator == '/'	*/
	{
		do_fraction_division (numerator1, denominator1, numerator2, denominator2, 
			numerator_final, denominator_final);
	}
	


	simplify_fraction (numerator_final, denominator_final);
	
	display_fraction (numerator1, denominator1);
	

	cout<<' '
		<<arithmetic_operator
		<<' ';
	

	display_fraction (numerator2, denominator2);
	

	cout<<" = ";
	

	display_fraction (numerator_final, denominator_final);
	

	cout<<endl;
	
		
	return EXIT_SUCCESS;
}


/******************************Start of Function Definitions*************************************/


/*
The function reads from the user the numerator and denominator of a fraction, insisting that the 
denominator not be 0.
preconditions: none
postconditions: recieves two integers from user, ensures that the second int is nonzero, and 
modifies arguments that are referenced by the function's 2 pass-by-reference varaiables.
*/
void get_fraction (int & numerator, int & denominator)
{
	cout<<"Please enter a numerator: ";
	cin>>numerator;

	do
	{
		cout<<"Please enter a nonzero denominator: ";
		cin>>denominator;
	} while(denominator == 0);
}


/*
The function displays the numerator and denominator of a fraction, with a '/' in between them.
preconditions: denominator must be nonzero
postconditions: prints value of first argument, a slash, and the value of the second argument.
*/
void display_fraction (int numerator, int denominator)
{
	cout<<numerator
		<<'/'
		<<denominator;
}


/*
The function simplifies the input fraction and returns to its caller with the corresponding 
values of numerator and denominator.
preconditions: denominator must be nonzero
postconditions: modifies pass-by-reference variables
*/
void simplify_fraction (int & numerator, int & denominator)
{
	int new_numerator, new_denominator;

	if ( (numerator < 0) && (denominator < 0 ) )
	{
		numerator = abs(numerator);
		denominator = abs(denominator);
	}
	
	int i;
	for (i = 1; i <= denominator; i++)
	{
		if( (numerator%i == 0) && (denominator%i == 0) )
		{
			new_numerator = numerator/i;
			new_denominator = denominator/i;
		}
	}

	numerator = new_numerator;
	denominator = new_denominator;

}


/*
The function requests and validates a arithmetic operation symbol from the user
preconditions: none
postconditions: returns a character which represents an arithmetic operator
*/
char get_arithmetic_operator(void)
{
	char arithmetic_operator;
	
	do
	{
	cout<<"Please enter the arithmetic operation you would like to perform (+, -, *, /): ";
	
	cin>>arithmetic_operator;
	
	} while ( (arithmetic_operator != '+') && (arithmetic_operator != '-') && 
			  (arithmetic_operator != '*') && (arithmetic_operator != '/') );

	return arithmetic_operator;

}


/*
The performs desired arithmetic operations of two fractions.
preconditions: recieved denominator values must be nonzero; and the recieved char must represent
a arithmetic operator
postconditions: returns a character which represents an arithmetic operator
*/
void do_fraction_addition (int numerator1, int denominator1, int numerator2, int denominator2, 
						   int& resulting_numerator, int& resulting_denominator)
{
	simplify_fraction (numerator1, denominator1);
	simplify_fraction (numerator2, denominator2);
	resulting_numerator = (numerator1 * denominator2) + (numerator2 * denominator1);
	resulting_denominator = denominator1 * denominator2;
}


/*
The performs desired arithmetic operations of two fractions.
preconditions: recieved denominator values must be nonzero; and the recieved char must represent
a arithmetic operator
postconditions: returns a character which represents an arithmetic operator
*/
void do_fraction_subtraction (int numerator1, int denominator1, int numerator2, int denominator2, 
								int& resulting_numerator, int& resulting_denominator)
{
	simplify_fraction (numerator1, denominator1);
	simplify_fraction (numerator2, denominator2);
	resulting_numerator = (numerator1 * denominator2) - (numerator2 * denominator1);
	resulting_denominator = denominator1 * denominator2;
}


/*
The performs desired arithmetic operations of two fractions.
preconditions: recieved denominator values must be nonzero; and the recieved char must represent
a arithmetic operator
postconditions: returns a character which represents an arithmetic operator
*/
void do_fraction_multiplication (int numerator1, int denominator1, int numerator2, 
								   int denominator2, int& resulting_numerator, 
								   int& resulting_denominator)
{
	simplify_fraction (numerator1, denominator1);
	simplify_fraction (numerator2, denominator2);
	resulting_numerator = numerator1 * numerator2;
	resulting_denominator = denominator1 * denominator2;
}


/*
The performs desired arithmetic operations of two fractions.
preconditions: recieved denominator values must be nonzero; and the recieved char must represent
a arithmetic operator
postconditions: returns a character which represents an arithmetic operator
*/
void do_fraction_division (int numerator1, int denominator1, int numerator2, int denominator2, 
							 int& resulting_numerator, int& resulting_denominator)
{
	simplify_fraction (numerator1, denominator1);
	simplify_fraction (numerator2, denominator2);
	resulting_numerator = numerator1 * denominator2;
	resulting_denominator = denominator1 * numerator2;
}