123.cpp

有理数的运算

#include <iostream.h>
#include <fstream.h>
#include <iomanip.h>
#include<stdio.h>
#include<math.h>
//using namespace std;
//////////////////////////////////////////////////////////
//符号函数
int sign(int value){
	if(value>0) return 1;
	else if(value==0) return 0;
	else return -1;
}
//最大公约数函数 
int divisor(int m,int n){
	int r;
	if(m==0&&n==0)
		return 0;
	if(m<0)
		m=-m; 
	if(n<0) 
		n=-n; 
	if(m==0) 
		return n; 
	if(n==0) 
		return m; 
	r=m%n; 	
	while(r!=0){ 
		m=n; 
		n=r; 
		r=m%n;
	} 
	return n;
} 
//////////////////////////////////////// 
//有理数类定义
class rationalnumber{
public:
	rationalnumber();
    rationalnumber(int,int); 
	rationalnumber(double,double);
    rationalnumber(int);
    rationalnumber(double);
    rationalnumber(rationalnumber &);
    ~rationalnumber(){};
	//访问数据
	int num()
	{return numerator;}
	int den()
	{return denominator;}
	double dec()
	{return decimal;}
	void normalize();
	void operator=(int&);
	void operator=(double& );
    void operator=(rationalnumber& );
	//普通运算符重载
    rationalnumber operator+(rationalnumber& );
    rationalnumber operator-(rationalnumber& );
    rationalnumber operator*(rationalnumber& );
    rationalnumber operator/(rationalnumber& );
	//比较运算符重载
    bool operator>(rationalnumber& );
    bool operator<(rationalnumber& );
    bool operator>=(rationalnumber& );
    bool operator<=(rationalnumber& );
    bool operator==(rationalnumber& );
    bool operator!=(rationalnumber& );
	//函数重载
	friend rationalnumber pow(rationalnumber,rationalnumber);
    friend rationalnumber abs(rationalnumber);
    friend rationalnumber sqrt(rationalnumber);
    friend rationalnumber sin(rationalnumber);
    friend rationalnumber cos(rationalnumber);
    friend rationalnumber tan(rationalnumber);
    friend rationalnumber asin(rationalnumber);
    friend rationalnumber acos(rationalnumber);
    friend rationalnumber atan(rationalnumber);
	friend rationalnumber down(rationalnumber);
	friend rationalnumber ln(rationalnumber);
	friend rationalnumber log(rationalnumber,rationalnumber);
	//提取插入运算符重载
	friend ostream & operator <<(ostream &,rationalnumber &);
    friend istream & operator >>(istream &,rationalnumber &);
 private:
    int numerator; //分子
    int denominator; //分母
    double decimal;
}; 
/////////////////////////////////////////////////////
//正规化函数 
void rationalnumber::normalize(){
	int signal=sign(numerator)*sign(denominator);
	int d=divisor(numerator,denominator);
	numerator=signal*(abs(numerator)/d); 
	denominator=abs(denominator)/d;
} 
//构造函数实现
//为有理数赋默认值0
rationalnumber::rationalnumber():numerator(0),denominator(1){
	decimal=0.0;
}
//为有理数赋值分子、分母
rationalnumber::rationalnumber(int numer,int denomin){
	numerator=numer;
	denominator=denomin;
	normalize();
	decimal=(double)numer/denomin;
}
rationalnumber::rationalnumber(double numer,double denomin){
	decimal=numer/denomin;
	double deci=decimal;
	while(1){
		double z=0;
		double b=modf(numer,&z);
		double c=modf(denomin,&z);
	    if(b!=0&&c!=0)
		{numer=numer*10;
         denomin=denomin*10;
		}
		else
			break;
	}
	int di=divisor((int)numer,(int)denomin);
	numerator=(int)numer/di;
	denominator=(int)denomin/di;
	normalize();
}
//当输入为小数时，为有理数赋值
rationalnumber::rationalnumber(double deci){
	int i=1;
	decimal=deci;
	while(1){
		double z=0;
		double b=modf(deci,&z);
	    if(b!=0.0)
		{deci=deci*10;i=i*10;}
		else
			break;
	}
	int di=divisor((int)deci,i);
	numerator=(int)deci/di;
	denominator=i/di;
	normalize();
}
//当输入为整数时，为有理数赋值
rationalnumber::rationalnumber(int numer){
	numerator=numer;
	denominator=1;
	decimal=(double)numerator;
}
////////////////////////////////////
//拷贝构造函数实现
rationalnumber::rationalnumber(rationalnumber &rat){
	numerator=rat.num();
	denominator=rat.den();
	decimal=rat.dec();
}
///////////////////////////////////
//重载运算符=
//整数赋值给rationalnumber
void rationalnumber::operator=(int &a){
	decimal=a;
	numerator=a;
	denominator=1;
}
//小数赋值给rationalnumber
void rationalnumber::operator=(double &a){
    int i=1;
	decimal=a;
	while(1){
		double z=0;
		double b=modf(a,&z);
	    if(b!=0)
		{a=a*10;i=i*10;}
		else
			break;
	}
	int di=divisor((int)a,i);
	numerator=(int)a/di;
	denominator=i/di;
}
//有理数给有理数赋值
void rationalnumber::operator=(rationalnumber &rat){
     numerator=rat.num();
     denominator=rat.den();
	 decimal=rat.dec();
}
//重载运算符+
rationalnumber rationalnumber::operator+(rationalnumber &rat){
   rationalnumber ratn(numerator*rat.den()+denominator*rat.num(),denominator*rat.den());
 return ratn;
}
//重载运算符-
rationalnumber rationalnumber::operator-(rationalnumber &rat){
      rationalnumber ratn(numerator*rat.den()-denominator*rat.num(),denominator*rat.den());
      return ratn;
}
//重载运算符*
rationalnumber rationalnumber::operator*(rationalnumber &rat){
	rationalnumber ratn(numerator*rat.num(),denominator*rat.den());
  return ratn;
}
//重载运算符/
rationalnumber rationalnumber::operator/(rationalnumber &rat){
    rationalnumber ratn(numerator*rat.den(),denominator*rat.num());
  return ratn;
}
//重载运算符>
bool rationalnumber::operator>(rationalnumber &rat){
	if(this->decimal-rat.dec()>0)
		return true;
	else 
		return false;
}
//重载运算符<
bool rationalnumber::operator<(rationalnumber &rat){
	if(this->decimal-rat.dec()<0)
		return true;
	else 
		return false;
}
//重载运算符>=
bool  rationalnumber::operator>=(rationalnumber &rat){
	if(this->decimal-rat.dec()>=0)
    	return true;
	else 
		return false;
}
//重载运算符<=
bool rationalnumber::operator<=(rationalnumber &rat){
	if(this->decimal-rat.dec()<=0)
		return true;
	else 
		return false;
}
//重载运算符==
bool rationalnumber::operator==(rationalnumber &rat){
	if(this->decimal-rat.dec()==0)
		return true;
	else 
		return false;
}

//重载运算符!=
bool rationalnumber::operator!=(rationalnumber &rat){
	if(this->decimal-rat.dec()!=0)
		return true;
	else 
		return false;
}

//pow乘方函数重载
rationalnumber pow(rationalnumber rat1,rationalnumber rat2){
	rationalnumber r=pow(rat1.dec(),rat2.dec());
	return r;
}
rationalnumber pow(rationalnumber rat1){
	rationalnumber r=pow(rat1.dec(),2);
	return r;
}
//sqrt开方函数重载
rationalnumber sqrt(rationalnumber rat){
	 rationalnumber r=sqrt(rat.dec());
	 return r;
}
//正弦函数sin（）重载
rationalnumber  sin(rationalnumber rat){
	rationalnumber r=sin(rat.dec());
	return r;
}
//余弦函数cos（）重载
rationalnumber  cos(rationalnumber rat){
	rationalnumber r=cos(rat.dec());
	return r;
}
//反正弦函数asin（）重载
rationalnumber  asin(rationalnumber rat){
	rationalnumber r=asin(rat.dec());
    return r;
}
//反余弦函数acos（）重载
rationalnumber  acos(rationalnumber rat){
	rationalnumber r=acos(rat.dec());
	 return r;
}
//正切函数tan（）重载
rationalnumber  tan(rationalnumber rat){
	rationalnumber r=tan(rat.dec());
	 return r;
}
//反正切函数atan（）重载
rationalnumber  atan(rationalnumber rat){
	rationalnumber r=down(tan(rat.dec()));
	 return r;
}
//定义求倒数函数down（）
rationalnumber down(rationalnumber rat){
	rationalnumber r=rationalnumber(rat.den(),rat.num());
	 return r;
}
//有理数的绝对值 
rationalnumber abs(rationalnumber rat){
	if(rat.dec()>=0)
		return rat;
	else
	{rationalnumber r=rationalnumber(-rat.dec());
	return r;}
}

//ln()函数求自然对数
rationalnumber ln(rationalnumber rat){
	return log(rat.decimal);
}
//log()函数求自然对数
rationalnumber log(rationalnumber rat1,rationalnumber rat2){
	return log(rat2.decimal)/log(rat1.decimal);
}
//<<重载
ostream &operator<<(ostream &output,rationalnumber &rat){
	if(rat.num()==0)
		output<<"0";
	else if(rat.den()==0)
		output<<"结果不存在！";
	else if(rat.den()==1)
		output<<rat.num();
	else{
		output<<rat.num()<<"/"<<rat.den(); }
    return output;} 
//>>重载
istream &operator>>(istream &input,rationalnumber &rat){
   	double a,b; 
    input>>a; 
    char c; 
    c=input.get(); 
    if(c=='/') 
    {input>>b; 
	rationalnumber newrat(a,b);
	rat=newrat;}
    else{ 
    input.putback(c); 
    rationalnumber newrat(a);
    rat=newrat;} 
    return input;
}

/////////////////////////////////////////////////////////////////////////
//定义有理数组类并排序