#include "math.h"
#include <iostream.h>

#define MAX_INT 32767

class Fractie  
{	
private:
	int nr;
	unsigned int nm;
	void corectieSemn(int&, int&);
	int cmMdc(int, int);
	int cmmmc(int,int);
public:	
	Fractie(int,int);
	Fractie(int);
	Fractie(double);
	Fractie();
			
	void simplifica(int);
	void amplifica(int);
	void reduce();

	Fractie operator+(Fractie&);	
	Fractie operator+(int);	
	Fractie operator+(double);
	Fractie operator-(Fractie&);	
	Fractie operator-(int);
	Fractie operator-(double);
	Fractie operator*(Fractie&);	
	Fractie operator*(int);
	Fractie operator*(double);
	Fractie operator/(Fractie&);	
	Fractie operator/(int);
	Fractie operator/(double);	

	friend ostream& operator<<(ostream&, Fractie&);
	friend istream& operator>>(istream&, Fractie&);

	bool operator<(Fractie&);
	bool operator>(Fractie&);
	bool operator<=(Fractie&);
	bool operator>=(Fractie&);
	bool operator==(Fractie&);
	bool operator!=(Fractie&);
};


Fractie::Fractie(int pnr, int pnm)
{
	if (pnm == 0)
	{
		nr = MAX_INT;
		nm = 1;
		cout << "\n\aEroare numitor zero. Fractie setata pe 1/MAX_INT\a\n";
	}
	else
	{
		corectieSemn(pnr, pnm);
		nr = pnr;
		nm = pnm;		
	}
}

Fractie::Fractie(int pnr)
{
	nr = pnr;
	nm = 1;
}

Fractie::Fractie(double numar)
{	
	double intg, frac;

	nm = 1;
	frac = modf(numar, &intg);
	while (frac != 0)
	{
		numar *= 10;
		nm *= 10;
		frac = modf(numar, &intg);
	}
	nr = (int)intg;
	reduce();
}

Fractie::Fractie()
{
	nr = 0;
	nm = 1;
}



void Fractie::corectieSemn(int& pnr, int& pnm)
{
	if (pnm < 0)
	{
		pnm *= -1;
		pnr *= -1;
	}
}

void Fractie::reduce()
{
	if (nr == MAX_INT)
	{
		cout << "\aFractia MAX_INT/1 nu se poate reduce.\n\a";
		return;
	}

	int cmmdc = cmMdc(nr, nm);
	nr /= cmmdc;
	nm /= cmmdc;
}

int Fractie::cmMdc(int a, int b)
{
	if (a == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu are cmMdc.\n\a";
		return MAX_INT;
	}

	corectieSemn(a, b);
	if (a < 0)	
		a *= -1;
	
	if(a < b)	
	{
		a = a + b;
		b = a - b;
		a = a - b;
	}

	if (b == 0) return 1;

	int rest = a % b;
	while (rest)
	{
		a = b;
		b = rest;
		rest = a % b;
	}

	return b;
}

int Fractie::cmmmc(int a, int b)
{
	if (a == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu are cmmmc.\n\a";
		return MAX_INT;
	}
	return a * b / cmMdc(a, b);
}

void Fractie::amplifica(int coef)
{
	if (nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate fi amplificata.\n\a";
		return;
	}
	if (coef != 0)
	{
		this->nr *= coef;
		this->nm *= coef;
	}
}

void Fractie::simplifica(int coef)
{
	if (nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate fi simplificata.\n\a";
		return;
	}

	if (coef != 0)
		if (this->nr % coef == 0 && this->nm % coef == 0)
		{
			this->nr /= coef;
			this->nm /= coef;
		}
}



Fractie Fractie::operator+(Fractie& termen)
{	
	if (nr == MAX_INT || termen.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia +\n\a";
		return *this;
	}

	Fractie rezultat;	
	rezultat.nm = cmmmc(termen.nm, this->nm);
	rezultat.nr = (rezultat.nm / this->nm * this->nr) + 
			      (rezultat.nm / termen.nm * termen.nr);

	rezultat.reduce();

	return rezultat;
}

Fractie Fractie::operator+(int termen)
{
	if (nr == MAX_INT || termen == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia +\n\a";
		return *this;
	}

	Fractie rezultat;	
	rezultat.nm = this->nm;
	rezultat.nr = (rezultat.nm / this->nm * this->nr) + 
			      (rezultat.nm * termen);

	rezultat.reduce();

	return rezultat;
}

Fractie Fractie::operator+(double termen)
{
	Fractie rezultat(termen);

	if (nr == MAX_INT || rezultat.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia +\n\a";
		return *this;
	}

	return (*this + rezultat);
}



Fractie Fractie::operator-(Fractie& termen)
{
	if (nr == MAX_INT || termen.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia -\n\a";
		return *this;
	}


	Fractie rezultat;
	rezultat.nm = cmmmc(termen.nm, this->nm);
	rezultat.nr = (rezultat.nm / this->nm * this->nr) - 
			      (rezultat.nm / termen.nm * termen.nr);

	rezultat.reduce();

	return rezultat;
}

Fractie Fractie::operator-(int termen)
{
	if (nr == MAX_INT || termen == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia -\n\a";
		return *this;
	}


	Fractie rezultat;	
	rezultat.nm = this->nm;
	rezultat.nr = (rezultat.nm / this->nm * this->nr) - 
			      (rezultat.nr * termen);

	rezultat.reduce();

	return rezultat;
}

Fractie Fractie::operator-(double termen)
{
	Fractie rezultat(termen);

	if (nr == MAX_INT || rezultat.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia -\n\a";
		return *this;
	}

	return (*this - rezultat);
}


Fractie Fractie::operator*(Fractie& termen)
{	
	if (nr == MAX_INT || termen.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia *\n\a";
		return *this;
	}

	Fractie rezultat(this->nr * termen.nr, this->nm * termen.nm);
	rezultat.reduce();

	return rezultat;
}

Fractie Fractie::operator*(int termen)
{
	if (nr == MAX_INT || termen == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia *\n\a";
		return *this;
	}

	Fractie rezultat(this->nr * termen, this->nm);
	rezultat.reduce();

	return rezultat;
}

Fractie Fractie::operator*(double termen)
{
	Fractie rezultat(termen);

	if (nr == MAX_INT || rezultat.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia *\n\a";
		return *this;
	}	

	return (*this * rezultat);
}


Fractie Fractie::operator/(Fractie& termen)
{	
	if (nr == MAX_INT || termen.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia /\n\a";
		return *this;
	}

	Fractie rezultat(this->nr * termen.nm, this->nm * termen.nr);
	rezultat.reduce();

	return rezultat;
}

Fractie Fractie::operator/(int termen)
{
	if (nr == MAX_INT || termen == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia /\n\a";
		return *this;
	}

	Fractie rezultat(this->nr, this->nm * termen);
	rezultat.reduce();

	return rezultat;
}

Fractie Fractie::operator/(double termen)
{
	Fractie rezultat(termen);

	if (nr == MAX_INT || rezultat.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in operatia /\n\a";
		return *this;
	}	

	return (*this / rezultat);
}


bool Fractie::operator==(Fractie& termen)
{
	termen.reduce();
	this->reduce();

	return (termen.nr == 0) && (this->nr == 0) ||
		   (this->nm == termen.nm) && (this->nr == termen.nr);
}

bool Fractie::operator<(Fractie& termen)
{
	if (nr == MAX_INT || termen.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in relatia <\n\a";
		return false;
	}

	return this->nr * termen.nm < termen.nr * this->nm;
}

bool Fractie::operator>(Fractie& termen)
{
	if (nr == MAX_INT || termen.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in relatia >\n\a";
		return false;
	}

	return this->nr * termen.nm > termen.nr * this->nm;
}

bool Fractie::operator!=(Fractie& termen)
{
	return !(*this == termen);
}

bool Fractie::operator>=(Fractie& termen)
{
	if (nr == MAX_INT || termen.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in relatia >=\n\a";
		return false;
	}

	return !(*this < termen);
}

bool Fractie::operator<=(Fractie& termen)
{
	if (nr == MAX_INT || termen.nr == MAX_INT)
	{
		cout << "\a\nFractia MAX_INT/1 nu poate aparea in relatia <=\n\a";
		return false;
	}

	return !(*this > termen);
}

/* **********    operatori I/O     *************************************/

ostream& operator<<(ostream& os, Fractie& termen)
{
	if (termen.nr == MAX_INT)	
	   os << "MAX_INT/1" << " ";	
	else
	   os << termen.nr << "/" << termen.nm << " ";
	
	return os;
}

istream& operator>>(istream& is, Fractie& termen)
{	
	cout << "Numaratorul : ";
	is >> termen.nr;
	cout << "Numitorul : ";
	is >> termen.nm;

	return is;
}

/************************************************************************
							   MAIN
************************************************************************/
char* bool2str(bool val)
{
	return val ? "True" : "False";
}

void main(int argc, char* argv[])
{	
	// Test 1	
	Fractie a(10, 20), b(2), c(0.375), d(12, -14), e(7, 0);

	// Test 2
	cout << "Test2 : a= b= c= " << a << b << c << d << e << "\n";

	// Test 3
	cout << "Test3 : " << a << " + " << b << " = " << a + b << "\n";

	// Test 4
	cout << "Test3 : (" << a << " + " << b << ") * " << c << " = " << (a + b) * c << "\n";

	// Test 5
	cout << "Test5 : a= b= c= " << a << b << c << d << e << "\n";

	// Test 6
	cout << "Test6 : " << a << " + " << b << " * " << c << " = " << a + b * c << "\n";

	// Test 7
	cout << "Test7 : " << a << " + " << b << " * " << c << " >= " 
		 << "(" << a << " + " << b << ") * " << c 
		 << bool2str(a + b * c > (a + b) * c) << "\n";

	// Test 8
	cout << "Test8 : Amplifica " << d << " cu 4 =";
	d.amplifica(4);
	cout << d << "\n";

	// Test 9
	cout << "Test9 : Simplifica " << d << " cu 2 =";
	d.simplifica(2);
	cout << d << "\n";

	// Test 10
	cout << "Test10 : reduce " << d << " = ";
	d.reduce();
	cout << d << "\n";

	// Test 11
	cout << "\n";
	cout << "Test11 : compara " << d << " != " << e << bool2str(d != e) << "\n";
}