cmath.cpp

计算一切超大数据功能,包括所有实数的一些基本的运算（不足之处望网友多多指教)

//========================================================
//取反运算
void Cmath::Not_integer(Csjd &x)
{
	Csjd I;
	I.insert('-',1);
	I.insert('1',2);
	this->Sub_integer(I,x);
}
//======================================================== 
//浮点型数据小数部分的四舍五入
void Cmath::Sjd_Round_Float(void)
{
	Csjd I,J,S,II;
	int n,length;;
	n=this->data.GetlastChar()-48;
	J.insert('1',1);
	J.insert('0',2);
	if(n>=5)
	{
		Cmath C;
		I.copysjd(this->data);
		this->data.freesjd();
		II.get_behind_decimaldata(I);  //小数部分
		length=II.lengthlist();
		S.ChangeIntoSjd(length-1);
		S.insert('-',1);
		C.Powc_integer(J,S);
		J.freesjd();
		J.copysjd(C.data);
		C.data.freesjd();
		C.Add_float(I,J);
		this->data.copysjd(C.data);
		this->data.deletelast();
		return;
	}
	this->data.deletelast();
}
//======================================================== 
//将浮点型数据小数部分精确到第num位
void Cmath::Sjd_Exactitude(int num)
{
	sjd *p;
	for(p=this->data.data->next;p!=NULL && p->ch!='.';p=p->next);
	if(p)
	{
		int i=0;
		while(i<=num && p)
		{
			p=p->next;
			i++;
		}
		if(p)
		{
			sjd *q,*t;
			q=p->next;
			t=q->next;
			p->next=NULL;
			while(t!=NULL)
			{
				free(q);
				q=t;
				t=t->next;
			}
			free(q);
		}
		this->Sjd_Round_Float();
	}
}
//========================================================
//向右移位运算
void Cmath::Lsh_integer(Csjd &x)
{

}
//========================================================
//取浮点数的小数部分
void Cmath::Int(Csjd &x)
{

} 
//========================================================
//将十进制数据转换成二进制数据
void Cmath::ChangeAlgorismIntoBinary_system_integer()
{
	Csjd I,T1,T2;
	Cmath A,B;  //定义两个数学环境
	int flag=0;
	I.insert('2',1);  //进制数I
	if(this->data.data->next==NULL)
	{
		printf("无数据!\n");
		return;
	}
	if(this->data.data->next->ch=='0' && this->data.data->next->next==NULL)  //为零时
		return;
	if(this->data.data->next->ch=='-')
	{
		data.deletesjd(1);
		flag=1;
	}
	T1.copysjd(this->data);   //记录原始数据
	this->data.freesjd();
	while(T1.data->next->ch!='0')
	{
		A.Division_integer(T1,I);  //T1
		B.Modc_integer(T1,I);   //T2
		T1.freesjd();
		T1.copysjd(A.data);
		A.data.freesjd();
		T2.copysjd(B.data);
		this->data.insertlastCsjd(T2);
		T2.freesjd();
		B.data.freesjd();
	}
	this->data.handstandsjd();
	if(flag)
		data.insert('-',1);
	this->data.dowithsjd();
}
//========================================================
//将二进制数据转换成十进制数据
void Cmath::ChangeBinary_systemIntoAlgorism_integer()
{
	int i,j,flag=0;
	Csjd I,T1,T2,T3,C;
	Cmath A,B;  //定义两个数学环境
	I.insert('2',1);  //进制数I
	if(this->data.data->next==NULL)
	{
		printf("无数据!\n");
		return;
	}
	if(this->data.data->next->ch=='0' && this->data.data->next->next==NULL)  //为零时
		return;
	if(this->data.data->next->ch=='-')
	{
		data.deletesjd(1);
		flag=1;
	}
	T1.copysjd(this->data);   //记录原始数据
	this->data.freesjd();
	this->data.initsjdlist();
	i=T1.lengthlist();
	j=1;
	while(j<=i)
	{
		if(T1.searchc(j)=='1')
		{
			C.ChangeIntoSjd(i-j);
			A.Powc_integer(I,C);
			C.freesjd();
			T2.copysjd(A.data);
			A.data.freesjd();
			T3.copysjd(this->data);
			this->data.freesjd();
			this->Add_integer(T2,T3);
			T2.freesjd();
			T3.freesjd();
		}
		j++;
	}
	if(flag)
		data.insert('-',1);
	this->data.dowithsjd();
}
//========================================================
//将十进制数据转换成m进制数据
void Cmath::ChangeAlgorismIntoM_system_integer(int n)
{
	Csjd I,T1,T2;
	Cmath A,B;  //定义两个数学环境
	int flag=0;
	I.ChangeIntoSjd(n);  //进制数I
	if(this->data.data->next==NULL)
	{
		printf("无数据!\n");
		return;
	}
	if(this->data.data->next->ch=='0' && this->data.data->next->next==NULL)  //为零时
		return;
	if(this->data.data->next->ch=='-')
	{
		data.deletesjd(1);
		flag=1;
	}
	T1.copysjd(this->data);   //记录原始数据
	this->data.freesjd();
	while(T1.data->next->ch!='0')
	{
		A.Division_integer(T1,I);  //T1
		B.Modc_integer(T1,I);   //T2
		T1.freesjd();
		T1.copysjd(A.data);
		A.data.freesjd();
		T2.copysjd(B.data);
		this->data.insertlastCsjd(T2);
		T2.freesjd();
		B.data.freesjd();
	}
	this->data.handstandsjd();
	if(flag)
		data.insert('-',1);
	this->data.dowithsjd();
}
//========================================================
//将m进制数据转换成十进制数据
void Cmath::ChangeM_systemIntoAlgorism_integer(int n)
{
	int i,j,flag=0;
	Csjd I,T1,T2,T3,C,D,E;
	Cmath A,B;  //定义两个数学环境
	I.ChangeIntoSjd(n);  //进制数I
	if(this->data.data->next==NULL)
	{
		printf("无数据!\n");
		return;
	}
	if(this->data.data->next->ch=='0' && this->data.data->next->next==NULL)  //为零时
		return;
	if(this->data.data->next->ch=='-')
	{
		data.deletesjd(1);
		flag=1;
	}
	T1.copysjd(this->data);   //记录原始数据
	this->data.freesjd();
	this->data.initsjdlist();
	i=T1.lengthlist();
	j=1;
	while(j<=i)
	{
		if(T1.searchc(j)!='0')
		{
			C.ChangeIntoSjd(i-j);
			A.Powc_integer(I,C);
			C.freesjd();		
			D.copysjd(A.data);
			A.data.freesjd();
			E.ChangeIntoSjd(T1.searchc(j)-48);
			A.By_integer(D,E);
			E.freesjd();
			D.freesjd();
			T2.copysjd(A.data);
			A.data.freesjd();
			T3.copysjd(this->data);
			this->data.freesjd();
			this->Add_integer(T2,T3);
			T2.freesjd();
			T3.freesjd();
		}
		j++;
	}
	if(flag)
		data.insert('-',1);
	this->data.dowithsjd();
}
//-------------------------------------------------------------------------
//========================================================
void Cmath::Add_float(Csjd &x,Csjd &y) //加法
{
	int flag=0;
	if(x.data->next->ch=='-' && y.data->next->ch=='-')
	{
		x.deletesjd(1);y.deletesjd(1);
		flag=1;
	}
	if(x.data->next->ch!='-' && y.data->next->ch=='-')
	{
		y.deletesjd(1);
		Cmath A;
		A.Sub_float(x,y);
		this->data.copysjd(A.data);
		y.insert('-',1);
		return;
	}
	if(x.data->next->ch=='-' && y.data->next->ch!='-')
	{
		x.deletesjd(1);
		Cmath A;
		A.Sub_float(y,x);
		this->data.copysjd(A.data);
		x.insert('-',1);
		return;
	}
	Csjd xI,xF,yI,yF;
	Afxdispose_the_float_part(x,y);
	xI.get_front_decimaldata(x);
	xF.get_behind_decimaldata(x);
	yI.get_front_decimaldata(y);
	yF.get_behind_decimaldata(y);
	int lengthB=xF.lengthlist();
	Cmath A,B;
	A.Add_integer(xI,yI);
	B.Add_integer(xF,yF);
	int e,f,n=0;
	e=B.data.lengthlist();
	f=yF.lengthlist();
	if(e<f)
		n=f-e;
	for(int i=0;i<n;i++)
		B.data.insert('0',1);
	int lengthL=B.data.lengthlist();
	if(lengthB!=lengthL)
	{
		Csjd T,I;
		I.insert('1',1);
		T.copysjd(A.data);
		A.data.freesjd();
		A.Add_integer(T,I);
		B.data.deletesjd(1);
	}
	this->data.copysjd(A.data);
	this->data.insertlast('.');
	this->data.insertlastCsjd(B.data);
	if(flag)
	{
		this->data.insert('-',1);
		x.insert('-',1);
		y.insert('-',1);
	}
	this->data.dowithsjd();
}
//========================================================
void Cmath::Sub_float(Csjd &x,Csjd &y)  //减法
{
	int flag=0;
	if(x.data->next->ch=='-' && y.data->next->ch=='-')
	{
		x.deletesjd(1);y.deletesjd(1);
		flag=1;		
	}
	if(x.data->next->ch!='-' && y.data->next->ch=='-')
	{
		y.deletesjd(1);
		Cmath A;
		A.Add_float(x,y);
		this->data.copysjd(A.data);
		y.insert('-',1);
		return;
	}
	if(x.data->next->ch=='-' && y.data->next->ch!='-')
	{
		x.deletesjd(1);
		Cmath A;
		A.Add_float(x,y);
		this->data.copysjd(A.data);
		x.insert('-',1);
		this->data.insert('-',1);
		return;
	}
	if(::AfxjudgeF(x,y)<0)
	{
		Cmath A;
		A.Sub_float(y,x);
		this->data.copysjd(A.data);
		this->data.insert('-',1);
		int tlag=0;
		if(this->data.data->next->ch=='-')
			tlag=1;
		if(!(tlag^flag))
		{
			this->data.insert('-',1);
			x.insert('-',1);
			y.insert('-',1);
		}
		return;
	}
	Csjd xI,xF,yI,yF;
	Afxdispose_the_float_part(x,y);
	xI.get_front_decimaldata(x);
	xF.get_behind_decimaldata(x);
	yI.get_front_decimaldata(y);
	yF.get_behind_decimaldata(y);
	Cmath A,B;
	if(::Afxjudge(xF,yF)<0)
	{
		xF.insert('1',1);
		Cmath C;
		Csjd I;
		I.insert('1',1);
		C.Sub_integer(xI,I);
		xI.freesjd();
		xI.copysjd(C.data);
	}
	A.Sub_integer(xI,yI);
	B.Sub_integer(xF,yF);
	int e,f,n=0;
	f=yF.lengthlist();
	e=B.data.lengthlist();
	if(f>e)
		n=f-e;
	for(int i=0;i<n;i++)
		B.data.insert('0',1);
	this->data.copysjd(A.data);
	this->data.insertlast('.');
	this->data.insertlastCsjd(B.data);
	int tlag=0;
	if(this->data.data->next->ch=='-')
		tlag=1;
	if(tlag^flag)
	{
		this->data.insert('-',1);
		x.insert('-',1);
		y.insert('-',1);
	}
	this->data.dowithsjd();
}
//========================================================
void Cmath::By_float(Csjd &x,Csjd &y)//乘法
{
	Csjd pF,qF,p,q;
	p.copysjd(x);
	q.copysjd(y);
	pF.get_behind_decimaldata(p);
	qF.get_behind_decimaldata(q);
	Cmath A,B;
	int LpF,LqF,LF;
	LpF=pF.lengthlist();
	LqF=qF.lengthlist();
	LF=LpF+LqF;
	p.movedecimal_right(LpF);
	q.movedecimal_right(LqF);
	p.ChangeIntointeger();
	q.ChangeIntointeger();
	this->By_integer(p,q);
	this->data.movedecimal_left(LF);
	this->data.dowithsjd();
}
//========================================================
void Cmath::Division_float(Csjd &x,Csjd &y,int digit) //除法
{
	int LpF,LqF,LF,i=0,flag=0,tlag=0;
	Cmath A,B;
	Csjd pF,qF,p,q,PPF,PPI,result,temp,T;
	if(x.data->next->ch=='-')
		flag=1;
	if(y.data->next->ch=='-')
		tlag=1;
	if(::AfxjudgeF(x,y)==0)
	{
		this->data.insertlast('1');
		this->data.insertlast('.');
		this->data.insertlast('0');
		return;
	}
	p.copysjd(x);
	q.copysjd(y);
	pF.get_behind_decimaldata(p);
	qF.get_behind_decimaldata(q);
	LqF=qF.lengthlist();  //一除数为基准 即以q为基准
	LpF=pF.lengthlist();   //p为被除数
	LF=LpF>LqF?LqF:LpF;
	p.movedecimal_right(LqF);
	q.movedecimal_right(LqF);
	PPI.get_front_decimaldata(p);
	PPF.get_behind_decimaldata(p);
	q.ChangeIntointeger();
	//------------------------//
	//整数部分
	A.Division_integer(PPI,q);
	B.Modc_integer(PPI,q);
	result.copysjd(A.data);  //记录结果
	A.data.freesjd();
	result.ChangeIntofloat(); //转换为浮点型
	temp.copysjd(B.data);
	B.data.freesjd();
	temp.insertlast(PPF.searchc(++i));
	PPI.freesjd();
	PPI.copysjd(temp);
	temp.freesjd();
	result.deletelast();
	//-----------------------//
	while(1)
	{
		A.Division_integer(PPI,q);
		B.Modc_integer(PPI,q);
		T.copysjd(A.data);  //累加数据
		A.data.freesjd();
		result.insertlastCsjd(T);
		T.freesjd();  //将此数据释放掉
		temp.copysjd(B.data);
		B.data.freesjd();
		if(PPF.searchc(++i))
			temp.insertlast(PPF.searchc(i));
		else
			temp.insertlast('0');
		PPI.freesjd();
		PPI.copysjd(temp);
		temp.freesjd();
		if(i==digit+2)
		{
			Cmath C;
			C.data.copysjd(result);
			C.Sjd_Round_Float();
			result.freesjd();
			result.copysjd(C.data);
			break;
		}
	}
	this->data.copysjd(result);
	this->data.dowithsjd();
	if(flag^tlag)
		this->data.insert('-',1);
}
//========================================================
void Cmath::Modc_float(Csjd &x,Csjd &y)  //求模
{
	int LpF,LqF,LF;
	Cmath B;
	Csjd pF,qF,p,q,PPF,PPI,result;
	p.copysjd(x);
	q.copysjd(y);
	pF.get_behind_decimaldata(p);
	qF.get_behind_decimaldata(q);
	LqF=qF.lengthlist();  //一除数为基准 即以q为基准
	LpF=pF.lengthlist();   //p为被除数
	LF=LpF>LqF?LqF:LpF;
	p.movedecimal_right(LqF);
	q.movedecimal_right(LqF);
	PPI.get_front_decimaldata(p);
	PPF.get_behind_decimaldata(p);
	q.ChangeIntointeger();
	//------------------------//
	//整数部分
	B.Modc_integer(PPI,q);
	result.copysjd(B.data);
	B.data.freesjd();
	result.ChangeIntofloat();
	result.deletelast();
	for(sjd  *t=PPF.data->next;t!=NULL;t=t->next)
		result.insertlast(t->ch);
	result.movedecimal_left(LqF);
	this->data.copysjd(result);
	this->data.dowithsjd();
}
//========================================================
void Cmath::Powc_float(Csjd &x,Csjd &y)  //求幂
{
	
}
//========================================================
void Cmath::Factorial_float(Csjd &x)  //求阶乘
{

}
//========================================================
void Cmath::ChangeAlgorismIntoBinary_system_float(int Precision)  //将十进制数据转换成二进制数据
{
	Csjd pI,pF,J;
	Cmath A,B;
	pI.get_front_decimaldata(this->data);  //整数部分
	A.data.copysjd(pI);
	A.ChangeAlgorismIntoBinary_system_integer();
	pI.freesjd();
	pI.copysjd(A.data);
	A.data.freesjd();
	pI.insertlast('.');

	pF.get_behind_decimaldata(this->data); //小数部分
	pF.insert('.',1);
	pF.insert('0',1);
	J.ChangeIntoSjd(2);
	J.ChangeIntofloat();
	for(int i=0;i<Precision;i++)
	{
		B.By_float(pF,J);
		pF.freesjd();
		pF.copysjd(B.data);
		B.data.freesjd();
		if(pF.data->next->ch=='1')
			pI.insertlast('1');
		else
			pI.insertlast('0');
		pF.mend(1,'0');
	}
	this->data.freesjd();
	this->data.copysjd(pI);
	this->data.dowithsjd();
}
//========================================================
void Cmath::ChangeBinary_systemIntoAlgorism_float()  //将二进制数据转换成十进制数据
{
	Csjd pI,pF,J,I;
	Cmath A,B;
	sjd *p;
	int i;
	I.ChangeIntoSjd(2);
	pI.get_front_decimaldata(this->data);  //整数部分
	A.data.copysjd(pI);
	A.ChangeBinary_systemIntoAlgorism_integer();
	pI.freesjd();
	pI.copysjd(A.data);
	pI.ChangeIntofloat();

	pF.get_behind_decimaldata(this->data); //小数部分
	for(i=1,p=pF.data->next;p!=NULL;p=p->next,i++)
	{
		if(p->ch=='1')
		{
			J.ChangeIntoSjd(-1*i);
			B.Powc_integer(I,J);
			J.freesjd();
			A.data.freesjd();
			A.Add_float(pI,B.data);
			B.data.freesjd();
			pI.freesjd();
			pI.copysjd(A.data);
		}
	}
	this->data.freesjd();
	this->data.copysjd(pI);
	this->data.dowithsjd();
}
//========================================================
void Cmath::ChangeAlgorismIntoM_system_float(int n)  //将十进制数据转换成m进制数据
{

}
//========================================================
void Cmath::ChangeM_systemIntoAlgorism_float(int n)  //将m进制数据转换成十进制数据
{

}
//========================================================
void Cmath::ChangeIntoSjd_float(int x)  //将一个整形数据转换成sjd数据类型
{

}
//========================================================
void Cmath::Or_float(Csjd &x,Csjd &y) //或运算
{

}
//========================================================
void Cmath::And_float(Csjd &x,Csjd &y) //与运算
{
	
}
//========================================================
void Cmath::Xor_float(Csjd &x,Csjd &y) //异或运算
{

}
//========================================================
void Cmath::Not_float(Csjd &x) //取反运算
{
	this->Not_integer(x);
}
//========================================================
void Cmath::Lsh_float(Csjd &x) //向右移位运算
{

}