Notes d'étude de calcul de haute précision

Qu'est-ce que le calcul de haute précision

L'algorithme de haute précision ( High the Accuracy Algorithm ) est une méthode mathématique de traitement de grands nombres. Dans les calculs scientifiques généraux , il est souvent calculé à quelques centaines de chiffres ou plus après la virgule décimale. Bien sûr, il peut aussi s'agir d'un grand nombre de centaines de milliards ou de dizaines de milliards. Généralement, ces types de nombres sont collectivement appelés nombres de haute précision. L'arithmétique de haute précision est une sorte de simulation par ordinateur de l' extraction d'addition, de soustraction, de multiplication, de division, de puissance , factorielle et carrée . Pour un très grand nombre qui ne peut pas être stocké normalement dans l'ordinateur, le nombre est décomposé, divisé en un stockage un par un ou à quatre chiffres à quatre chiffres dans un tableau , et un tableau est utilisé pour représenter un nombre, donc ce Les nombres sont appelés nombres de haute précision. Les algorithmes de haute précision sont des algorithmes qui peuvent gérer diverses opérations sur des nombres de haute précision, mais en raison de leurs particularités, ils sont séparés des algorithmes de nombres ordinaires et forment une famille.

Quand utiliser des calculs de haute précision

Lorsque la plage du nombre impliqué dans l'opération (addition, soustraction, facteur ...) dépasse largement la plage qui peut être représentée par les types de données standards (entier, réel, entier long). Par exemple, recherchez la somme de deux nombres de 20000 chiffres. À ce stade, il est nécessaire d'utiliser des algorithmes de haute précision .

Calcul de haute précision

Entier

#include<bits/stdc++.h> 
using namespace std;
struct Wint:vector<int>
{
	Wint(int n=0)
	{
		push_back(n);
		check();
	}
	Wint& check()
	{
		while(!empty()&&!back())pop_back();
		if(empty())return *this;
		for(int i=1; i<size(); ++i)
		{
			(*this)[i]+=(*this)[i-1]/10;
			(*this)[i-1]%=10;
		}
		while(back()>=10)
		{
			push_back(back()/10);
			(*this)[size()-2]%=10;
		}
		return *this;
	}
};
istream& operator>>(istream &is,Wint &n)
{
	string s;
	is>>s;
	n.clear();
	for(int i=s.size()-1; i>=0; --i)n.push_back(s[i]-'0');
	return is;
}
ostream& operator<<(ostream &os,const Wint &n)
{
	if(n.empty())os<<0;
	for(int i=n.size()-1; i>=0; --i)os<<n[i];
	return os;
}
bool operator!=(const Wint &a,const Wint &b)
{
	if(a.size()!=b.size())return 1;
	for(int i=a.size()-1; i>=0; --i)
		if(a[i]!=b[i])return 1;
	return 0;
}
bool operator==(const Wint &a,const Wint &b)
{
	return !(a!=b);
}
bool operator<(const Wint &a,const Wint &b)
{
	if(a.size()!=b.size())
		return a.size()<b.size();
	for(int i=a.size()-1; i>=0; --i)
		if(a[i]!=b[i])return a[i]<b[i];
	return 0;
}
bool operator>(const Wint &a,const Wint &b)
{
	return b<a;
}
bool operator<=(const Wint &a,const Wint &b)
{
	return !(a>b);
}
bool operator>=(const Wint &a,const Wint &b)
{
	return !(a<b);
}
Wint& operator+=(Wint &a,const Wint &b)
{
	if(a.size()<b.size())
	{
		a.resize(b.size());
	}
	for(int i=0; i!=b.size();++i)
	{
		a[i]+=b[i];
	}
	return a.check();
}
Wint operator+(Wint a,const Wint &b)
{
	return a+=b;
}
Wint& operator-=(Wint &a,Wint b)
{
	if(a<b)swap(a,b);
	for(int i=0;i!=b.size();a[i]-=b[i],++i)
		if(a[i]<b[i])
		{
			int j=i+1;
			while(!a[j])++j;
			while(j>i)
			{
				--a[j];
				a[--j]+=10;
			}
		}
	return a.check();
}
Wint operator-(Wint a,const Wint &b)
{
	return a-=b;
}
Wint operator*(const Wint &a,const Wint &b)
{
	Wint n;
	n.assign(a.size()+b.size()-1,0);
	for(int i=0;i!=a.size();++i)
	{
		for(int j=0;j!=b.size();++j)
		{
			n[i+j]+=a[i]*b[j];
		}
	}
	return n.check();
}
Wint& operator*=(Wint &a,const Wint &b)
{
	return a=a*b;
}
Wint divmod(Wint &a,const Wint &b)
{
	Wint ans;
	for(int t=a.size()-b.size(); a>=b; --t)
	{
		Wint d;
		d.assign(t+1,0);
		d.back()=1;
		Wint c=b*d;
		while(a>=c)
		{
			a-=c;
			ans+=d;
		}
	}
	return ans;
}
Wint operator/(Wint a,const Wint &b)
{
	return divmod(a,b);
}
Wint& operator/=(Wint &a,const Wint &b)
{
	return a=a/b;
}
Wint& operator%=(Wint &a,const Wint &b)
{
	divmod(a,b);
	return a;
}
Wint operator%(Wint a,const Wint &b)
{
	return a%=b;
}
Wint pow(const Wint &n,const Wint &k)
{
	if(k.empty())return 1;
	if(k==2)return n*n;
	if(k.front()%2)return n*pow(n,k-1);
	return pow(pow(n,k/2),2);
}
int main()
{
	Wint a,b;
	cin>>a>>b;
	cout<<(a<b)<<endl<<(a==b)<<endl<<a+b<<endl<<a-b<<endl<<a*b<<endl<<a/b<<endl<<a%b<<endl<<pow(a,b);
	return 0;
}

Point flottant

#include<bits/stdc++.h>
using namespace std;
struct Wint:vector<int>
{
	Wint(int n=0)
	{
		push_back(n);
		check();
	}
	Wint& check()
	{
		while(!empty()&&!back())pop_back();
		if(empty())return *this;
		for(int i=1; i<size(); ++i)
		{
			(*this)[i]+=(*this)[i-1]/10;
			(*this)[i-1]%=10;
		}
		while(back()>=10)
		{
			push_back(back()/10);
			(*this)[size()-2]%=10;
		}
		return *this;
	}
};
istream& operator>>(istream &is,Wint &n)
{
	string s;
	is>>s;
	n.clear();
	for(int i=s.size()-1; i>=0; --i)n.push_back(s[i]-'0');
	return is;
}
ostream& operator<<(ostream &os,const Wint &n)
{
	if(n.empty())os<<0;
	for(int i=n.size()-1; i>=0; --i)os<<n[i];
	return os;
}
bool operator!=(const Wint &a,const Wint &b)
{
	if(a.size()!=b.size())return 1;
	for(int i=a.size()-1; i>=0; --i)
		if(a[i]!=b[i])return 1;
	return 0;
}
bool operator==(const Wint &a,const Wint &b)
{
	return !(a!=b);
}
bool operator<(const Wint &a,const Wint &b)
{
	if(a.size()!=b.size())return a.size()<b.size();
	for(int i=a.size()-1; i>=0; --i)
		if(a[i]!=b[i])return a[i]<b[i];
	return 0;
}
bool operator>(const Wint &a,const Wint &b)
{
	return b<a;
}
bool operator<=(const Wint &a,const Wint &b)
{
	return !(a>b);
}
bool operator>=(const Wint &a,const Wint &b)
{
	return !(a<b);
}
Wint& operator+=(Wint &a,const Wint &b)
{
	if(a.size()<b.size())a.resize(b.size());
	for(int i=0; i!=b.size(); ++i)a[i]+=b[i];
	return a.check();
}
Wint operator+(Wint a,const Wint &b)
{
	return a+=b;
}
Wint& operator-=(Wint &a,Wint b)
{
	if(a<b)swap(a,b);
	for(int i=0; i!=b.size(); a[i]-=b[i],++i)
		if(a[i]<b[i])
		{
			int j=i+1;
			while(!a[j])++j;
			while(j>i)
			{
				--a[j];
				a[--j]+=10;
			}
		}
	return a.check();
}
Wint operator-(Wint a,const Wint &b)
{
	return a-=b;
}
Wint operator*(const Wint &a,const Wint &b)
{
	Wint n;
	n.assign(a.size()+b.size()-1,0);
	for(int i=0; i!=a.size(); ++i)
		for(int j=0; j!=b.size(); ++j)
			n[i+j]+=a[i]*b[j];
	return n.check();
}
Wint& operator*=(Wint &a,const Wint &b)
{
	return a=a*b;
}
Wint divmod(Wint &a,const Wint &b)
{
	Wint ans;
	for(int t=a.size()-b.size(); a>=b; --t)
	{
		Wint d;
		d.assign(t+1,0);
		d.back()=1;
		Wint c=b*d;
		while(a>=c)
		{
			a-=c;
			ans+=d;
		}
	}
	return ans;
}
Wint operator/(Wint a,const Wint &b)
{
	return divmod(a,b);
}
Wint& operator/=(Wint &a,const Wint &b)
{
	return a=a/b;
}
Wint& operator%=(Wint &a,const Wint &b)
{
	divmod(a,b);
	return a;
}
Wint operator%(Wint a,const Wint &b)
{
	return a%=b;
}
Wint pow(const Wint &n,const Wint &k)
{
	if(k.empty())return 1;
	if(k==2)return n*n;
	if(k.front()%2)return n*pow(n,k-1);
	return pow(pow(n,k/2),2);
}
int main()
{
	Wint a,b;
	cin>>a>>b;
	cout<<(a<b)<<endl<<(a==b)<<endl<<a+b<<endl<<a-b<<endl<<a*b<<endl<<a/b<<endl<<a%b<<endl<<pow(a,b);
	return 0;
}