cmath.cpp

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

#include"Cmath.h"
//======================================================
//标准构造函数
Cmath::Cmath()
{
	
}

//======================================================
//标准析构函数
Cmath::~Cmath()
{
	
}

//========================================================
//加法(将数据链x加上数据链y并返回加后的结果数据链z)
void Cmath::Add_integer(Csjd &x,Csjd &y)
{
	int i=1,j=0,m,n,jg=0,s=0,g=0,flag=0;
	char ch;
	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);
		this->Sub_integer(x,y);
		y.insert('-',1);
		return;
	}
	if(x.data->next->ch=='-' && y.data->next->ch!='-')
	{
		x.deletesjd(1);
		this->Sub_integer(y,x);
		x.insert('-',1);
		return;
	}
	x.handstandsjd();y.handstandsjd();
	while(x.searchc(i)!='\0' || y.searchc(i)!='\0')
	{
		if(x.searchc(i)=='\0')
			m=0;
		else
			m=x.searchc(i)-48;
		if(y.searchc(i)=='\0')
			n=0;
		else
			n=y.searchc(i)-48;
		jg=m+n+s;
		g=jg%10;
		s=jg/10;
		ch=g+48;
		data.insert(ch,++j);
		i++;
	}
	data.insert(s+48,++j);
	x.handstandsjd();y.handstandsjd();data.handstandsjd();
	data.dowithsjd();
	if(flag)
	{
		x.insert('-',1);y.insert('-',1);
		this->data.insert('-',1);
	}
	this->data.dowithsjd();
}
//========================================================
//减法(将数据链x减去数据链y并返回减后的结果数据链z)
void Cmath::Sub_integer(Csjd &x,Csjd &y)
{
	Csjd p,q;sjd *t1=::Afxinit(),*t2=t1;
	int i=1,j=0,m,n,jg=0,flag=0,tlag=0;
	char ch;
	p.copysjd(x);
	q.copysjd(y);
	if(::Afxjudge(x,y)==0)
	{
		p.freesjd();q.freesjd();
		data.insertlast('0');
		return;
	}
	if(p.data->next->ch=='-' && q.data->next->ch!='-')
	{
		p.deletesjd(1);
		this->Add_integer(p,q);
		this->data.insert('-',1);
		return;
	}
	if(p.data->next->ch!='-' && q.data->next->ch=='-')
	{
		q.deletesjd(1);
		this->Add_integer(p,q);
		return;
	}
	if(p.data->next->ch=='-' && q.data->next->ch=='-')
	{
		p.deletesjd(1);
		q.deletesjd(1);
		flag=1;
	}
	if(::Afxjudge(p,q)<0)
	{*t1=*p.data;*p.data=*q.data;*q.data=*t1;tlag=1;}

	p.handstandsjd();q.handstandsjd();
	while(p.searchc(i)!='\0' || q.searchc(i)!='\0')
	{
		if(p.searchc(i)=='\0')
			m=0;
		else
			m=p.searchc(i)-48;
		if(q.searchc(i)=='\0')
			n=0;
		else
			n=q.searchc(i)-48;
		if(m<n)
		{
			m+=10;
			jg=m-n;
			ch=p.searchc(i+1);
			ch-=1;
			p.mend(i+1,ch);
		}
		else
			jg=m-n;
		ch=jg+48;
		data.insert(ch,++j);
		i++;
	}
	data.handstandsjd();
	data.dowithsjd();
	if(flag^tlag)
		data.insert('-',1);
	this->data.dowithsjd();
}
//======================================================
//乘法(将数据链x乘以数据链y并返回乘后的结果数据链z)
void Cmath::By_integer(Csjd &x,Csjd &y)
{
	int i,j,m,n,jg=0,s=0,g=0,flag=0;
	char ch;
	if(x.data->next->ch=='-' && y.data->next->ch=='-')
	{
		flag=1;
		x.deletesjd(1);
		y.deletesjd(1);
	}
	if(x.data->next->ch!='-' && y.data->next->ch=='-')
	{
		flag=2;
		y.deletesjd(1);
	}
	if(x.data->next->ch=='-' && y.data->next->ch!='-')
	{
		flag=3;
		x.deletesjd(1);
	}
	x.handstandsjd();y.handstandsjd();
	if(x.lengthlist()==1 && x.data->next->ch=='0' || y.lengthlist()==1 && y.data->next->ch=='0')
	{
		data.initsjdlist();
		return;
	}
	i=1;										//以下是计算阶段
	while(1)
	{
		j=1;
		if(y.searchc(i)=='\0')
			break;
		m=y.searchc(i)-48;
		while(1)
		{
			if(x.searchc(j)=='\0')
				break;
			n=x.searchc(j)-48;
			if(data.searchc(i+j-1)=='\0')
				jg=m*n+s;
			else
				jg=m*n+s+data.searchc(i+j-1)-48;
			s=jg/10;
			g=jg%10;
			ch=g+48;
			if(data.searchc(i+j-1)!='\0')
				data.mend(i+j-1,ch);
			else
				data.insert(ch,i+j-1);
			j++;
		}
		data.insert(s+48,i+j-1);
		s=0;
		i++;
	}
	x.handstandsjd();y.handstandsjd();data.handstandsjd();
	data.dowithsjd();
	if(flag==1)
	{
		x.insert('-',1);
		y.insert('-',1);
	}
	if(flag==2)
	{
		y.insert('-',1);
		data.insert('-',1);
	}
	if(flag==3)
	{
		x.insert('-',1);
		data.insert('-',1);
	}
	this->data.dowithsjd();
}
//========================================================
//除法(将数据链x除去数据链y并返回除后的结果数据链z)
void Cmath::Division_integer(Csjd &x,Csjd &y)
{
	Csjd p;
	Cmath t;
	int m=0,n,length=0,flag=0;
	char ch;
	if(x.data->next->ch=='-' && y.data->next->ch=='-')
	{
		flag=1;
		x.deletesjd(1);
		y.deletesjd(1);
	}
	if(x.data->next->ch!='-' && y.data->next->ch=='-')
	{
		flag=2;
		y.deletesjd(1);
	}
	if(x.data->next->ch=='-' && y.data->next->ch!='-')
	{
		flag=3;
		x.deletesjd(1);
	}
	if(y.lengthlist()==1 && y.data->next->ch=='0')
	{
		printf("除数不能为零!\n");
		return;
	}
	if(::Afxjudge(x,y)<0)
	{
		data.insert('0',1);
		return;
	}
	else
	{
		length=y.lengthlist();
		p.getsubsjd(x,1,length);
        n=length;
		while(1)
		{
			if(::Afxjudge(p,y)<0)
				goto recom;
			while(::Afxjudge(p,y)>=0)
			{
				t.Sub_integer(p,y);
				++m;
				p.freesjd();
				p.copysjd(t.data);
				t.data.freesjd();
			}
recom:
			ch=m+48;
			data.insertlast(ch);
			if(++n==x.lengthlist()+1)
				break;
			ch=x.searchc(n);
			p.insertlast(ch);
			m=0;
			p.dowithsjd();
		}
	}
	data.dowithsjd();
	if(flag==1)
	{
		x.insert('-',1);
		y.insert('-',1);
	}
	if(flag==2)
	{
		y.insert('-',1);
		data.insert('-',1);
	}
	if(flag==3)
	{
		x.insert('-',1);
		data.insert('-',1);
	}
	this->data.dowithsjd();
}
//========================================================
//求模
void Cmath::Modc_integer(Csjd &x,Csjd &y)
{
	int n,length=0,flag=0;
	char ch;
	Csjd p;
	Cmath t;
	
	if(x.data->next->ch=='-' && y.data->next->ch=='-')
	{
		flag=1;
		x.deletesjd(1);
		y.deletesjd(1);
	}
	if(x.data->next->ch!='-' && y.data->next->ch=='-')
	{
		flag=2;
		y.deletesjd(1);
	}
	if(x.data->next->ch=='-' && y.data->next->ch!='-')
	{
		flag=3;
		x.deletesjd(1);
	}
	if(::Afxjudge(x,y)<0)
	{
		data.copysjd(x);
		if(flag==1)
		{
			x.insert('-',1);
			y.insert('-',1);
			data.insert('-',1);
		}
		if(flag==2)
		{
			y.insert('-',1);
			data.insert('-',1);
		}
		if(flag==3)
		{
			x.insert('-',1);
			data.insert('-',1);
		}
		return;
	}
	else
	{
		length=y.lengthlist();
		p.getsubsjd(x,1,length);
        n=length;
		while(1)
		{
			if(::Afxjudge(p,y)<0)
				goto recom;
			while(::Afxjudge(p,y)>=0)
			{
				t.Sub_integer(p,y);
				p.freesjd();
				p.copysjd(t.data);
				t.data.freesjd();
			}
recom:
			if(++n==x.lengthlist()+1)
			{
				data.copysjd(p);
				break;
			}
			ch=x.searchc(n);
			p.insertlast(ch);
			p.dowithsjd();;
		}
	}
	data.dowithsjd();
	if(flag==1)
	{
		x.insert('-',1);
		y.insert('-',1);
		data.insert('-',1);
	}
	if(flag==2)
	{
		y.insert('-',1);
		data.insert('-',1);
	}
	if(flag==3)
	{
		x.insert('-',1);
		data.insert('-',1);
	}
	this->data.dowithsjd();
}
//========================================================
//求幂
void Cmath::Powc_integer(Csjd &x,Csjd &y)
{
	int flag=0;
	Csjd I,p,q;
	Cmath A,B;  //创建两个数学环境
	if(y.data->next->ch=='0')
	{
		this->data.insert('1',1);
		return;
	}
	if(x.data->next->ch=='0')
	{
		this->data.insert(1,1);
		return;
	}
	if(y.data->next->ch=='-')
	{
		y.deletesjd(1);
		flag=1;
	}
	I.insertlast('1');  //单位1
	p.copysjd(y);  //计数器p
	q.copysjd(x);  //累加器
	A.Sub_integer(p,I);
	p.freesjd();
	p.copysjd(A.data);
	A.data.freesjd();
	for(;p.data->next->ch!='0';)
	{
		B.By_integer(q,x);
		q.freesjd();
		q.copysjd(B.data);
		B.data.freesjd();
		A.Sub_integer(p,I);
		p.freesjd();
		p.copysjd(A.data);
		A.data.freesjd();
	}
	if(flag)
	{
		Cmath C;
		q.ChangeIntofloat();
		C.GetReciprocal(1000,q);
		q.freesjd();
		q.copysjd(C.data);
	}
	data.copysjd(q);
	this->data.dowithsjd();
}
//========================================================
//求阶乘的运算
//利用this的数学环境处理相关运算,最后将结果放经本数学环境的内部变量成员data中
void Cmath::Factorial_integer(Csjd &x)  
{
	Csjd I,result,J;
	I.insert('1',1);
	result.copysjd(I);
	J.copysjd(I);
	while(::Afxjudge(J,x)<=0)
	{
		this->By_integer(result,J);   //用result存储结果
		result.freesjd();
		result.copysjd(this->data);
		this->data.freesjd();

		this->Add_integer(J,I);   //J加1
		J.freesjd();
		J.copysjd(this->data);
		this->data.freesjd();
	}
	this->data.copysjd(result);
	this->data.dowithsjd();
}
//======================================================== 
 //求派的值
void Cmath::GetPI(int Precision)
{
	Cmath A,B;
	int last,i=0;
	Csjd I,result,J,K,N,p,q,II;
	I.insert('1',1);  //单位1
	II.insert('2',1);  //单位2
	J.copysjd(I);
	result.initsjdlist();
	result.ChangeIntofloat();
	N.ChangeIntoSjd(10000);
	for(;::Afxjudge(J,N)<=0;)
	{
		last=J.GetlastChar()-48;

		/*B.Factorial_integer(J);
		B.data.ChangeIntofloat();
		K.copysjd(B.data);
		B.data.freesjd();
		A.GetReciprocal(Precision,K);
		K.freesjd();*/

		B.By_integer(II,J);
		K.copysjd(B.data);
		B.data.freesjd();  //2*j

		B.Sub_integer(K,I);
		K.freesjd();  //2*j-1

		B.data.ChangeIntofloat();   //1/(2*J-1)
		K.copysjd(B.data);
		B.data.freesjd();

		A.GetReciprocal(Precision,K);
		K.freesjd();

		p.copysjd(A.data);
		A.data.freesjd();
		if(!(last%2))
			p.insert('-',1);
		
		q.copysjd(result);
		result.freesjd();

		A.Add_float(q,p);
		p.freesjd();
		result.copysjd(A.data);
		result.display();
		printf("   %d\n",++i);

		q.freesjd();
		A.data.freesjd();
		//J自增--//
		B.Add_integer(J,I);
		J.freesjd();
		J.copysjd(B.data);
		B.data.freesjd();
		//J自增--//	
	}
	K.ChangeIntoSjd(4);
	K.ChangeIntofloat();
	result.display();
	B.By_float(result,K);
	result.freesjd();
	result.copysjd(B.data);
	this->data.copysjd(result);
	this->data.dowithsjd();
}
//======================================================== 
//求倒数
void Cmath::GetReciprocal(int Precision,Csjd &x)
{
	Csjd I;
	I.insert('1',1);
	I.ChangeIntofloat();
	this->Division_float(I,x,Precision);
	this->data.dowithsjd();
}
//========================================================
//或运算
void Cmath::Or_integer(Csjd &x,Csjd &y)
{
	int length1,length2,i,flag=0,tlag=0;
	char ch;
	Cmath A,B;
	A.data.copysjd(x);
	B.data.copysjd(y);
	A.ChangeAlgorismIntoBinary_system_integer();
	B.ChangeAlgorismIntoBinary_system_integer();
	if(A.data.data->next->ch=='-')
		A.data.deletesjd(1);
	if(B.data.data->next->ch=='-')
	{
		B.data.deletesjd(1);
		tlag=1;
	}
	length1=A.data.lengthlist()<B.data.lengthlist()? A.data.lengthlist():B.data.lengthlist();
	length2=A.data.lengthlist()>B.data.lengthlist()? A.data.lengthlist():B.data.lengthlist();
	if(A.data.lengthlist()>B.data.lengthlist()) flag=1;
	A.data.handstandsjd();
	B.data.handstandsjd();
	for(i=1;i<=length1;i++)
	{
		ch=((A.data.searchc(i)-48)|(B.data.searchc(i)-48))+48;
		this->data.insert(ch,i);
	}
	for(;i<=length2;i++)
	{
		if(flag)
			ch=A.data.searchc(i);
		else
			ch=B.data.searchc(i);
		this->data.insert(ch,i);
	}
	this->data.handstandsjd();
	this->ChangeBinary_systemIntoAlgorism_integer();
	if(tlag)
		this->data.insert('-',1);
	this->data.dowithsjd();
}
//========================================================
//与运算
void Cmath::And_integer(Csjd &x, Csjd &y)
{
	int length,i,flag=0,tlag=0;
	char ch;
	Cmath A,B;
	A.data.copysjd(x);
	B.data.copysjd(y);
	A.ChangeAlgorismIntoBinary_system_integer();
	B.ChangeAlgorismIntoBinary_system_integer();
	if(A.data.data->next->ch=='-')
		A.data.deletesjd(1);
	if(B.data.data->next->ch=='-')
	{
		B.data.deletesjd(1);
		tlag=1;
	}
	length=A.data.lengthlist()<B.data.lengthlist()? A.data.lengthlist():B.data.lengthlist();
	if(A.data.lengthlist()>B.data.lengthlist()) flag=1;
	A.data.handstandsjd();
	B.data.handstandsjd();
	for(i=1;i<=length;i++)
	{
		ch=((A.data.searchc(i)-48)&(B.data.searchc(i)-48))+48;
		this->data.insert(ch,i);
	}
	this->data.handstandsjd();
	this->ChangeBinary_systemIntoAlgorism_integer();	
	if(tlag && this->data.data->next->ch!='0' &&this->data.data->next->next!=NULL)
		this->data.insert('-',1);
	this->data.dowithsjd();
}
//========================================================
//异或运算
void Cmath::Xor_integer(Csjd &x, Csjd &y)
{
	int length1,length2,i,flag=0,tlag=0;
	char ch;
	Cmath A,B;
	A.data.copysjd(x);
	B.data.copysjd(y);
	A.ChangeAlgorismIntoBinary_system_integer();
	B.ChangeAlgorismIntoBinary_system_integer();
	if(A.data.data->next->ch=='-')
		A.data.deletesjd(1);
	if(B.data.data->next->ch=='-')
	{
		B.data.deletesjd(1);
		tlag=1;
	}
	length1=A.data.lengthlist()<B.data.lengthlist()? A.data.lengthlist():B.data.lengthlist();
	length2=A.data.lengthlist()>B.data.lengthlist()? A.data.lengthlist():B.data.lengthlist();
	if(A.data.lengthlist()>B.data.lengthlist()) flag=1;
	A.data.handstandsjd();
	B.data.handstandsjd();
	for(i=1;i<=length1;i++)
	{
		ch=((A.data.searchc(i)-48)^(B.data.searchc(i)-48))+48;
		this->data.insert(ch,i);
	}
	for(;i<=length2;i++)
	{
		if(flag)
			ch=A.data.searchc(i)^0;
		else
			ch=B.data.searchc(i)^0;
		this->data.insert(ch,i);
	}
	this->data.handstandsjd();
	this->ChangeBinary_systemIntoAlgorism_integer();	
	if(tlag)
		this->data.insert('-',1);
	this->data.dowithsjd();
}