// Crational.cpp: implementation of the rational class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Ex_BDSYL.h"
#include "Crational.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
#include "iostream.h"
#include "Crational.h"
Rational::Rational()
{
	this->fenZi=0;
    this->fenMu=1;
}
//----------------------------------------------------------------

Rational::Rational(int fenZi,int fenMu)
{
	this->fenZi=fenZi;
    this->fenMu=fenMu;
     HuaJian(*this);
}
//------------------------------------------------------------------
Rational::Rational(const Rational &p)
{
	fenZi=p.fenZi;
    fenMu=p.fenMu;

}

//-----------------------------------------------------------------
Rational  Rational::HuaJian( Rational &p)
 
{ int tem_ZDGY=ZDGY(p.fenZi,p.fenMu);
  p.fenMu=p.fenMu/tem_ZDGY;
  p.fenZi=p.fenZi/tem_ZDGY;
  if(0==p.fenZi)p.fenMu=1;
  if(0==p.fenMu){p.fenMu=1;p.fenZi=0;}
  if(p.fenMu<0){p.fenMu=-1*p.fenMu;p.fenZi=-1*p.fenZi;}
return p;
}
//------------------------------------------------------------------

int Rational::ZDGY(int x,int y)
{   if(0==x||0==y)
	{return 1 ;}
	if(y>x)
	{ y=x+y;
	  x=y-x;
	  y=y-x;
	}
	int r;
	do
	{
		r=x%y;
	     x=y;
		 y=r;
	}while(r!=0);
return x;
}
//--------------------------------------------------------------------


int Rational::ZXGB(int x,int y )
     
{   return x*y/ZDGY(x,y);

}
//----------------------------------------------------------------
void Rational::showR()
{cout<<this->fenZi<<endl;
cout<< this->fenMu<<endl<<endl;


}
//------------------------------------------------------------------------

Rational Rational::operator + (const Rational &p)

	{  
		int f2_Zi=p.fenZi;
		int f2_Mu=p.fenMu;
		
    
		int rlt_fM=ZXGB(fenMu,f2_Mu);
		int rlt_fZ=fenZi*rlt_fM/fenMu+f2_Zi*rlt_fM/f2_Mu;
		
		Rational R_result(rlt_fZ,rlt_fM);
		HuaJian(R_result);
		return  R_result;

	}
Rational Rational::operator +=(const Rational &p)
{
    *this=*this+p;
	return *this;
}
//---------------------------------------------------------------------------
Rational Rational::operator =(int n)
{  this->fenZi=n;
    this->fenMu=1;
	return (*this);
}
//-----------------------------------------------------------------------------
int  Rational:: operator ==(const Rational &p)  
 {   
	 if(fenMu==p.fenMu && fenZi==p.fenZi)
		 return 1;
	 else 
		 return 0;
 
 }
//----------------------------------------------------------------------------
int Rational:: operator !=(const Rational &p) 
{   
     if(fenMu!=p.fenMu || fenZi!=p.fenZi)
		 return 1;
	 else 
		 return 0;

}
//----------------------------------------------------------------------------

Rational Rational::operator -(const Rational &p)
{     
		int f2_Zi=p.fenZi;
		int f2_Mu=p.fenMu;

		int rlt_fM=ZXGB(fenMu,f2_Mu);
		int rlt_fZ=fenZi*rlt_fM/fenMu-f2_Zi*rlt_fM/f2_Mu;
		
		Rational R_result(rlt_fZ,rlt_fM);
		HuaJian(R_result);
		return  R_result;
}
//------------------------------------------------------------------------------
Rational Rational::operator *(const Rational &p)
{     
	    int f2_Zi=p.fenZi;
		int f2_Mu=p.fenMu;
        int f1_Zi=fenZi;
		int f1_Mu=fenMu;
		int tem_1=ZDGY(f1_Mu,f2_Zi);
		int tem_2=ZDGY(f1_Zi,f2_Mu);
		f1_Mu=f1_Mu/tem_1;
		f2_Zi=f2_Zi/tem_1;
		f1_Zi=f1_Zi/tem_2;
		f2_Mu=f2_Mu/tem_2;
        
     	int rlt_fM=f1_Mu*f2_Mu;
		int rlt_fZ=f1_Zi*f2_Zi;
		
		Rational R_result(rlt_fZ,rlt_fM);
			HuaJian(R_result);
		return  R_result;
}
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------------
Rational operator *(Rational &p,int n)
{  
   int fz=p.fenZi*n;
   int fm=p.fenMu;
  Rational result(fz,fm);
p.HuaJian(result); 
  return   result;


}
//----------------------------------------------------------------------------------
Rational operator *(int n,Rational &p)
{  
   int fz=p.fenZi*n;
   int fm=p.fenMu;
  Rational result(fz,fm);
   p.HuaJian(result);  
  return   result;


}


//----------------------------------------------------------------------------------
Rational Rational::operator /(const Rational &p)
{       

        int result_zi=p.fenMu;
		int result_mu=p.fenZi;
		Rational tem_p(result_zi,result_mu);
		return  (*this)*tem_p;
        

}

Rational Rational::operator /=(const Rational &p)
{  
    *this=*this/p;
	return *this;
}
int Rational::Getnum()
{
	return this->fenZi;
}
int Rational::Getden()
{
	return this->fenMu;
}
void Rational::Setnumden(int num,int den)
{ 
	this->fenZi=num;
  this->fenMu=den;
  HuaJian(*this);
}