// ---------------------------------
//   frac.cpp    fractions
// ---------------------------------
#include "frac.h"



	frac::frac(int ni, int di) : n(ni), d(di)
				 { normalize(); }

	frac::frac(const frac &f): n(f.n),d(f.d) {} 



	frac &frac::operator=(const frac &f)
		{ n = f.n; d = f.d; return *this; }


	void frac::normalize()
	  { int sn = 1, g = 1;
		 if (d == 0) { cout << "denominator = 0  ";
		               abort(); }
		 else
			{ if (((d > 0)&&(n < 0))||((d < 0)&&(n > 0)))
				{ sn = -1; n = abs(n); d = abs(d); }
			  g = gcd(n,d);
			  n = sn*n/g;  d = d/g; } }


 // ----------------------------------------------------
 // friends of frac

  int num(const frac &f)  // numerator
	  {return f.n; }

  int dnum(const frac &f) // denominator
	  { return f.d; }


  double eval(const frac &f)
	 { return (f.n/double(f.d)); }

  void peval(const frac &f)
	 { double z = eval(f);
		cout << z; }

  void pleval(const frac &f)
	 { peval(f); nl(); }

  frac operator+(const frac &f, const frac &g)
	  { frac r;
		 r.n = f.n*g.d + f.d*g.n;
		 r.d = f.d*g.d;
		 r.normalize();
		 return r; }

  frac operator*(const frac &f, const frac &g)
	  { frac r;
		 r.n = f.n*g.n;
		 r.d = f.d*g.d;
		 r.normalize();
		 return r; }

  frac operator/(const frac &f, const frac &g)
	  { frac r;
		 r.n = f.n*g.d;
		 r.d = f.d*g.n;
		 r.normalize();
		 return r; }

  int operator>(const frac &f, const frac &g)
  {
	  return (f.n*g.d > f.d*g.n ? 1 : 0);
  }

	void r(frac &f)
	 { char divsgn;
		int di,ni;
		cin >> ni >> divsgn >> di;
		f = frac(ni,di);
		f.normalize(); }

 // ----------------------------------------------------
 //  output functions

  void p(const frac &f)
	  { int n = num(f), d = dnum(f);
		 if (n == 0) cout << 0;
		 else { if (d == 1) cout << n;
				  else {
							frac fp(f);
							fp.normalize();
							cout << num(fp) << '/' << dnum(fp); }}}

  void pl(const frac &f)
	 { p(f); nl(); }