#include <iostream>

using namespace std;

namespace NumberAlgorithms
{
	template <class T> T Max(const T& a, const T& b) { return (a > b) ? a : b; }
	template <class T> T Min(const T& a, const T& b) { return (a < b) ? a : b; }

	template <class T> T GreatestCommonFactor(const T& a, const T& b)
	{
		T gcf = 1, max = Min(a, b);
		for (T i = 2; i < max; i++)
			if (a % i + b % i == 0)
				gcf = i;
		return gcf;
	}
	template <class T> T LeastCommonMultiple(const T& a, const T& b)
	{
		T max = a * b;
		for (T i = Min(a, b); i < max; i++;)
			if (i % a + i % b == 0)
				return i;
	}
};

// Fraction SHOULD be a struct, as it is a data type, and doesn't function
// with other objects. Other objects use it, but it doesn't depend on anything.

// T must be an number type (representing any real rational number)
template <class T>	// It is not possible to use constraints in c++
class Fraction		// So we have to assume that the user will use an integral type
{
private:
	T Numerator, Denominator;

	void Reduce()
	{
		T gcf = NumberAlgorithms::GreatestCommonFactor(Numerator, Denominator);
		Numerator /= gcf;
		Denominator /= gcf;
		if (Denominator < 0)
		{
			Numerator *= -1;
			Denominator *= -1;
		}
	}

public:
	Fraction() : Numerator(1), Denominator(1) { }
	Fraction(T n) : Numerator(n) { SetDenominator(1); }
	Fraction(T n, T d) : Numerator(n) { SetDenominator(d); }

	void SetNumerator(const T& value)
	{
		Numerator = value;
		Reduce();
	}
	T GetNumerator() const { return Numerator; }
	void SetDenominator(const T& value)
	{
		if (value == 0) throw std::exception("Divide by zero");
		Denominator = value;
		Reduce();
	}
	T GetDenominator() const { return Denominator; }

	friend ostream& operator<<(const ostream& output, const Fraction<T> value);
	friend istream& operator>>(const istream& input, Fraction<T> value);

	friend Fraction<T> operator+(const Fraction<T>& left, const Fraction<T>& right);
	friend Fraction<T> operator-(const Fraction<T>& left, const Fraction<T>& right);
	friend Fraction<T> operator*(const Fraction<T>& left, const Fraction<T>& right);
	friend Fraction<T> operator/(const Fraction<T>& left, const Fraction<T>& right);

	bool operator<(const Fraction<T>& right) const
	{
		T a = GetNumerator(), b = GetDenominator(), c = right.GetNumerator(), d = right.GetDenominator();

		return (a * d < b * c);
	}
	bool operator>(const Fraction<T>& right) const
	{
		T a = GetNumerator(), b = GetDenominator(), c = right.GetNumerator(), d = right.GetDenominator();

		return (a * d > b * c);
	}
	bool operator<=(const Fraction<T>& right) const
	{
		T a = GetNumerator(), b = GetDenominator(), c = right.GetNumerator(), d = right.GetDenominator();

		return (a * d <= b * c);
	}
	bool operator>=(const Fraction<T>& right) const
	{
		T a = GetNumerator(), b = GetDenominator(), c = right.GetNumerator(), d = right.GetDenominator();

		return (a * d >= b * c);
	}
	bool operator==(const Fraction<T>& right) const
	{
		T a = GetNumerator(), b = GetDenominator(), c = right.GetNumerator(), d = right.GetDenominator();

		return (a * d == b * c);
	}
	bool operator!=(const Fraction<T>& right) const
	{
		T a = GetNumerator(), b = GetDenominator(), c = right.GetNumerator(), d = right.GetDenominator();

		return (a * d != b * c);
	}
};

template <class T> Fraction<T> operator+(Fraction<T> const& left, Fraction<T> const& right)
{
	T a = left.GetNumerator(), b = left.GetDenominator(), c = right.GetNumerator(), d = right.GetDenominator(), x;

	using NumberAlgorithms;

	x = LeastCommonMultiple<T>(b, d);

	a *= x / d;
	b *= x / d;
	c *= x / b;
	d *= x / b;

	return Fraction<T>(a + b, c);
}
template <class T> Fraction<T> operator-(Fraction<T> const& left, Fraction<T> const& right)
{
	T a = left.GetNumerator(), b = left.GetDenominator(), c = right.GetNumerator(), d = right.GetDenominator(), x;

	using NumberAlgorithms;

	x = LeastCommonMultiple<T>(b, d);

	a *= x / d;
	b *= x / d;
	c *= x / b;
	d *= x / b;

	return Fraction<T>(a - b, c);
}
template <class T> Fraction<T> operator*(Fraction<T> const& left, Fraction<T> const& right)
{
	T a = left.GetNumerator(), b = left.GetDenominator(), c = right.GetNumerator(), d = right.GetDenominator();

	if (b == 0 || d == 0) throw exception("Divide by zero");

	return Fraction<T>(a * c, b * d);
}
template <class T> Fraction<T> operator/(Fraction<T> const& left, Fraction<T> const& right)
{
	T a = left.GetNumerator(), b = left.GetDenominator(), c = right.GetNumerator(), d = right.GetDenominator();

	if (c == 0 || d == 0) throw new exception("Divide by zero");

	return Fraction<T>(a * d, b * c);
}
template <class T> ostream& operator<<(const ostream& output, const Fraction<T>& value)
{
	output << value.Numerator << '/' << value.Denominator;

	return output;
}
template <class T> istream& operator>>(const istream& input, Fraction<T>& value)
{
	T n, d, char seperator;

	cin >> n >> seperator >> d;

	value.SetNumerator(n);
	value.SetDenominator(d);

	return input;
}

bool Test()
{
	char answer;
	Fraction<int> test1, test2, test3(10);
	int a, b;

	cout << endl << "Please enter two whole numbers. ex: a b : ";
	cin >> a >> b;
	test1 = Fraction<int>(a, b);

	cout << endl << "Please enter two whole numbers. ex: a/b : ";
	cin >> test2;

	 // Display the three values to test cout
    cout << "\nTest1 equals " << test1;
    cout << "\nTest2 equals " << test2;
    cout << "\nTest3 equals " << test3;
	// Test our operators
    cout << "\nTest1 * Test2 equals " << test1*test2;
    cout << "\nTest1 / Test3 equals " << test1/test3;
    cout << "\nTest2 + Test3 equals " << test2+test3;
    cout << "\nTest3 - Test1 equals " << test3-test1;
    if (test1 == test2)
        cout << "\nTest1 is equal to Test2";
    if (test1 < test2)
        cout << "\nTest1 is less than Test2";

	cout << "Would you like to test again? ";
	cin >> answer;

	return answer == 'Y' || answer == 'y';
}

int main()
{
	cout << endl << "Project 11-5" << endl << endl
		<< "Testing the Fraction class." << endl
		<< "The fraction class stores a numerator and denominator digit (n/d)" << endl
		<< "Let the testing commence!" << endl;

	while (Test()) ;
}