大整数运算包

最新推荐文章于 2022-02-24 08:45:29 发布
最新推荐文章于 2022-02-24 08:45:29 发布
阅读量556 收藏
点赞数 1
分类专栏： 计算机程序语法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hengfanz/article/details/23453299
版权
#include<iostream>
#include<cstdio>
#include<cstring>
#include<sstream>
//#include<time.h>
#include<stdlib.h>
using namespace std;
#define max(a,b) (a)>(b)?(a):(b)
#define min(a,b) (a)<(b)?(a):(b)
const int BIGN_MAXN=5000;
const int base=10;//oct base
const int MILLER_INDEX=100;
const int BINARY_LEN=5000;
const int NUM_STR_MAXN=5000;
//s[0]:0(0) >0(1) <0(-1)  (a>b)  definit condition
class bign
{
private:
    int len,s[BIGN_MAXN];//s[0]signal .. s[1--n]digital
public:
    bign()
    {
        len=0;
        memset(s,0,sizeof(s));
    }
    ~bign() {}
    //visit private members
    int& at(int pos)
    {
        if(pos>len) return s[0];//beyond the numble length ,output signal.
        else return s[pos];
    }
    int length() const
    {
        return len;
    }
    //assignment
    bign operator =(const char x[])
    {
        len=strlen(x);
        for(int i=1; i<=len; i++) s[i]=x[len-i]-'0';
        return *this;
    }
    bign operator =(const int x)
    {
        char xx[NUM_STR_MAXN];
        sprintf(xx,"%d",x);
        *this=xx;
        return *this;
    }
    bign(const char x[])
    {
        *this=x;
    }
    bign(const int x)
    {
        *this=x;
    }
    //to-string
    string str()const
    {
        string buf="";
        for(int i=len; i>0; i--) buf+=(char)(s[i]+'0');
        if(buf=="") buf = "0";
        return buf;
    }
    //comparision
    bool operator <(const bign& x)const
    {
        if(len!=x.len) return(len<x.len);
        for(int i=len; i>0; i--) if(s[i]!=x.s[i]) return(s[i]<x.s[i]);
        return false;
    }
    bool operator >(const bign& x)const
    {
        return x<*this;
    }
    bool operator ==(const bign& x)const
    {
        return (!(*this<x)&&(!(x<*this)));
    }
    bool operator !=(const bign& x)const
    {
        return (*this<x)||(x<*this);
    }
    bool operator <=(const bign& x)const
    {
        return !(x<*this);
    }
    bool operator >=(const bign& x)const
    {
        return !(*this<x);
    }
    //calculation
    bign operator + (const bign& x) const
    {
        bign ans;
int i,cy;
        int len=max(this->len, x.len)+1;//
        for(i=1; i<=len; i++)
        {
cy=0;
if(i<=(this->len))
cy+=this->s[i];
if(i<=x.len)
cy+=x.s[i];
            ans.s[i]+=cy;
            ans.s[i+1]=ans.s[i]/base;
            ans.s[i]%=base;
        }
        if(ans.s[len]==0&&len>0) len--;
        ans.len=len;
        //取模
        return ans;
    }
    bign operator +=(const bign& x)
    {
        *this=*this+x;
        return *this;
    }
    bign operator - (const bign& x) const
    {
        bign ans=0;
        int i,cy=0;
        for(ans.len=len,i=1; i<=ans.len; i++)
        {
            ans.s[i]=s[i]-cy;
            if(i<=x.len)
                ans.s[i]-=x.s[i];
            if(ans.s[i]<0)
            {
                cy=1;
                ans.s[i]+=base;
            }
            else
            {
                cy=0;
            }
        }
        while(ans.len>0&&ans.s[ans.len]==0)
            ans.len--;
        return ans;
    }
    bign operator -=(const bign& x)
    {
        *this=*this-x;
        return *this;
    }
    bign operator *(const bign& x) const
    {
        bign ans;
        int i,j;
        int len=this->len+x.len;
        for(i=1; i<=this->len; i++)
            for(j=1; j<=x.len; j++)
                ans.s[i+j-1]+=this->s[i]*x.s[j];
for(i=1; i<=len; i++)
{
ans.s[i+1]+=ans.s[i]/base;
ans.s[i]%=base;
}
while(ans.s[len]==0&&len>0) len--;
ans.len=len;
return ans;
    }
    bign operator *=(const bign& x)
    {
        *this=*this*x;
        return *this;
    }
    bign operator /(const int x) const
    {
        bign ans;
        if(*this<x)
        {
            ans=0;
            ans.len=1;
        }
        else
        {
            int k=0,len=this->len;
            for(int i=len; i>0; i--)
            {
                ans.s[i]=(k*base+this->s[i])/x;
                k=(k*base+this->s[i])%x;
            }
            while(ans.s[len]==0&&len>0) len--;
            ans.len=len;
        }
        return ans;
    }
    bign operator /=(const int x)
    {
        *this=*this/x;
        return *this;
    }
    bign operator /( const bign& b) const
    {
        bign q,mo,bas=base,tmp,ans,mod=0;//
        if(*this<b)
        {
            ans=0;
            ans.len=1;
        }
        int i,lf,rg,mid;
        for(i=len; i>0; i--)
        {
            mod*=bas;
            tmp=s[i];
            mod+=tmp;
            for(lf=0,rg=base-1; lf<rg;)
            {
                mid=(lf+rg+1)/2;
                q=mid;
                mo=b*q;
                if(mo<=mod)
                    lf=mid;
                else
                    rg=mid-1;
            }
            ans.s[i]=lf;
            mo=lf;
            mod=mod-(b*mo);
        }
        ans.len=len;
        while(ans.len>0&&ans.s[ans.len]==0)
            ans.len--;
        return ans;
    }
    bign operator /=(const bign& x)
    {
        *this=*this/x;
        return *this;
    }
    bign operator %( const bign& b) const
    {
        bign q,mo,bas=base,tmp,ans,mod=0;
        if(*this<b)
        {
            ans=*this;
            return ans;
        }
        int i,lf,rg,mid;
        for(i=len; i>0; i--)
        {
            mod*=bas;
            tmp=s[i];
            mod+=tmp;
            for(lf=0,rg=base-1; lf<rg;)
            {
                mid=(lf+rg+1)/2;
                q=mid;
                mo=b*q;
                if(mo<=mod)
                    lf=mid;
                else
                    rg=mid-1;
            }
            ans.s[i]=lf;
            mo=lf;
            mod=mod-(b*mo);
        }
        return mod;
    }
    bign operator %=(const bign& x)
    {
        *this=*this%x;
        return *this;
    }
bign operator &(const bign& xx)const {
bign mid,ans=0,zero=0,one=1,two=2,x=xx,thi=*this;
int str[BINARY_LEN],str1[BINARY_LEN],str2[BINARY_LEN],len1=0,len2=0;
while(thi>zero){
if((thi%two)==one)
str1[++len1]=1;
else
str1[++len1]=0;
            (thi)/=two;
}
cout<<"fuck"<<endl;
while(x>zero){
if((x%two)==one)
str2[++len2]=1;
else
str2[++len2]=0;
            x/=two;
}
int i,len=min(len1,len2);
        for(i=1;i<=len;i++){
str[i]=str1[i]&str2[i];
}
mid=1;
for(i=1;i<=len;i++){
if(str[i]==1)
ans+=mid;
mid*=two;
}
return ans;
}
bign operator |(const bign& xx)const {
bign mid,ans=0,zero=0,one=1,two=2,x=xx,thi=*this;
int str[BINARY_LEN],str1[BINARY_LEN],str2[BINARY_LEN],len1=0,len2=0;
while(thi>zero){
if((thi%two)==one)
str1[++len1]=1;
else
str1[++len1]=0;
            (thi)/=two;
}
while(x>zero){
if((x%two)==one)
str2[++len2]=1;
else
str2[++len2]=0;
            x/=two;
}
int i,len=max(len1,len2);
//cout<<len<<endl;
        for(i=1;i<=len;i++){
str[i]=str1[i]|str2[i];
//cout<<str[i]<<" ";
}
mid=1;
for(i=1;i<=len;i++){
if(str[i]==1){
ans+=mid;
//  cout<<"fuck"<<endl;
}
mid*=two;
}
//ans.len=len;
return ans;
}
    bign operator ^(const bign& xx)const {
bign mid,ans=0,zero=0,one=1,two=2,x=xx,thi=*this;
int str[BINARY_LEN],str1[BINARY_LEN],str2[BINARY_LEN],len1=0,len2=0;
while(thi>zero){
if((thi%two)==one)
str1[++len1]=1;
else
str1[++len1]=0;
            (thi)/=two;
}
while(x>zero){
if((x%two)==one)
str2[++len2]=1;
else
str2[++len2]=0;
            x/=two;
}
int i,len=max(len1,len2);
//cout<<len<<endl;
        for(i=1;i<=len;i++){
            if(str1[i]==str2[i])
str[i]=0;
else
str[i]=1;
//cout<<str[i]<<" ";
}
mid=1;
for(i=1;i<=len;i++){
if(str[i]==1){
ans+=mid;
//  cout<<"fuck"<<endl;
}
mid*=two;
}
//ans.len=len;
return ans;
}
    bign operator ~()const {
bign mid,ans=0,zero=0,one=1,two=2,thi=*this;
int i,str[BINARY_LEN],len=0;
while(thi>zero){
if((thi%two)==one)
str[++len]=0;
else
str[++len]=1;
            (thi)/=two;
}
mid=1;
for(i=1;i<=len;i++){
if(str[i]==1){
ans+=mid;
//cout<<"fuck"<<endl;
}
mid*=two;
}
//ans.len=len;
return ans;
}
    bign operator ++()
    {
        bign one=1;
        *this=*this+one;
        return *this;
    }
    bign operator --()
    {
        bign c=1;
        *this=*this-c;
        return *this;
    }
bign operator <<(const bign& x) const{
int i,str[BINARY_LEN],llen=0;
bign ans=0,lift=x,thi=*this;
bign mid,zero=0,one=1,two=2;
while(thi>zero){
if((thi%two)==one)
str[++llen]=1;
else
str[++llen]=0;
            (thi)/=two;
}
while(lift>zero){
llen++;
for(i=llen;i>1;i--)
str[i]=str[i-1];
str[1]=0;
lift-=one;
}
mid=1;
for(i=1;i<=llen;i++){
if(str[i]==1){
ans+=mid;
}
mid*=two;
}
return ans;
}
bign operator <<=(const bign& x)
    {
        *this=*this<<x;
        return *this;
    }
bign operator >>(const bign& x) const{
int i,str[BINARY_LEN],rlen=0;
bign Rlen,ans=0,right=x,thi=*this;
bign mid,zero=0,one=1,two=2;
while(thi>zero){
if((thi%two)==one)
str[++rlen]=1;
else
str[++rlen]=0;
            (thi)/=two;
}
Rlen=rlen;
if(Rlen<=right)
return ans;
else{
while(right>zero){
for(i=1;i<rlen;i++)
str[i]=str[i+1];
rlen--;
right-=one;
}
mid=1;
for(i=1;i<=rlen;i++){
if(str[i]==1){
ans+=mid;
}
mid*=two;
}
return ans;
}
}
bign operator >>=(const bign& x)
    {
        *this=*this>>x;
        return *this;
    }
};
//bign index=10000000007;
//input&output
istream& operator>>(istream& in,bign& x )
{
    string s;
    in >> s;
    x=s.c_str();
    return in;
}
ostream& operator<<(ostream& out,const bign& x)
{
    return out << x.str();
}
//gcd
bign gcd(bign x,bign y)
{
    bign mid,zero=0;
    if((x==zero)||(y==zero))
        return x>y?x:y;
    for(bign t;;)
    {
        t=x%y;
        if(t<=zero){
            break;
        }
        x=y;
        y=t;
    }
    return y;
}
//lcm
bign lcm(bign x,bign y)
{
bign mid=x*y;
return mid/gcd(x,y);
}
//pow
bign pow(bign x,bign n,bign mod)
{
    bign mid,pw=1,zero=0,one=1;
x=x%mod;
    while(n>zero)
    {
//cout<<mid<<endl;
mid=n&one;
cout<<mid<<endl;
        if(mid!=zero){
            pw*=x;
pw%=mod;
}
        x*=x;
x=x%mod;
        n>>=one;
cout<<n<<endl;
    }
    return pw;
}
//Euclidean_gcd
void exc_gcd(bign a,bign b,bign& d,bign& x,bign& y)
{
    bign mid,zero=0,index=10000000007;//
    if(b<=zero)
    {
        d=a;
        x=1;
        y=0;
    }
    else
    {
        exc_gcd(b,a%b,d,y,x);
mid=(x*(a/b))%index;
        if(y>=mid)
y-=mid;
else
y=(y+index-mid)%index;
    }
}
//inverse
bign inv(bign a,bign n)
{
    bign d,x,y,one=1,neg=-1;
    exc_gcd(a,n,d,x,y);
    return d==one?(x+n)%n:neg;//
}
//miller_rabin
int witness(bign a,bign n){
bign x,d=1,mid;int i=MILLER_INDEX;
bign one=1,zero=0,two=2;
for(;i>=0;i--){
x=d;
d=(d*d)%n;
mid=i;
if((d==one)&&(x!=one)&&(x!=(n-one)))
return 1;
if(((n-one)&(mid*two))>zero)
d=(d*a)%n;
}
if(d==one)
return 0;
else
return 1;
}

int miller(bign n,int s=50){
bign a,one=1,zero=0,two=2,RAND,RAND_M;
RAND_M=(int)RAND_MAX;
if(n==two)
return 1;
if((n%two)==zero)//
return 0;
int j;//
for(j=0;j<s;j++){
RAND=(int)rand();
a=((RAND*(n-two))/RAND_M)+one;
if(witness(a,n))
return 0;
}
return 1;
}
franztao
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大整数包的设计与运算
04-23
程序主要有三个文件组成，一个主函数，一个大整数包函数的头文件（里面定义了大整数包运算符的重载，以及字符类型的转换），一个大整数包的cpp文件。
大整数运算包的实现（Java）(1) --加、减、乘、除、模取余、模加（考虑负数）
H_X_P_的博客
01-29 1576
大整数运算包的实现（Java）(1) --加、减、乘、除、模取余、模加（考虑负数）
大整数运算
Tomorrow Never Knows
01-12 1154
本篇博客记录大整数运算相关问题。 包括： 1. 大整数的存储 2. 大整数的四则运算 1 大整数的存储 大整数又叫高精度数，一般指其范围已经超出了基本数据类型能够表示的范围的数。 很容易想到，对于高进度数我们需要用数组来存储。有以下几点注意事项： 1. 顺位存储 如123，我们这么保存：num[0] = 3, num[1] = 2, num[2] = 1，即整数的高位保存在数组...
大整数包(简单版）
hengfanz的专栏
04-11 653
#include #include #include #include #include #include using namespace std; const int MAXD = 500, DIG = 9, BASE = 1000000000; const unsigned long long BOUND = numeric_limits :: max ()
加减乘的大整数包
06-07
用c++程序实现了对大整数的加、减、 乘的运算，经测试，可行
大整数运算包的设计与实现
02-25
本项目聚焦于设计和实现一个大整数运算包，使用C++编程语言，并借助Visual Studio作为开发环境。以下是对这个项目的详细阐述。 首先，C++是一种强类型、静态类型的编程语言，它支持面向对象和泛型编程，这使得C++...
大整数的运算
03-15
在计算机科学中，大整数运算通常涉及到处理超出普通整型变量范围的数值。这篇描述提到了使用VC++ 6.0开发的大整数运算程序，该程序利用链表数据结构来存储和操作大整数，而不依赖于C++标准库中的`list`容器或内置...
C++实现的大整数四则运算
12-25
在C++中，大整数通常通过数组或向量存储，每个元素表示数字的一个位。数组或向量的长度可以动态调整，以适应任意大小的整数。大整数类可能包含以下主要成员： 1. **数据成员**：一个`std::vector<unsigned int>`或`...
基于c语言的大整数运算.rar
02-10
本资源"基于C语言的大整数运算.rar"显然关注的是C语言在处理大整数计算方面的能力。通常，C语言的标准库提供了一个称为`<stdio.h>`的基本数学操作集，但这些功能对超出常规整型范围的大整数处理支持有限。因此，...
关于大整数包的设计！
李树花开，风中摇曳
05-25 5865
C/C++中的int类型能表示的范围是-2E31－2E31–1。unsigned类型能表示的范围是0－2E32–1，即 0－4294967295。所以，int和unsigned类型变量，都不能保存超过10位的整数。有时我们需要参与运算的数，可能会远远不止10 位，例如，可能需要保留小数点后面100位（比如求π的值），那么，即便使用能表示很大数值范围的double变量，但是由于double变量只有6
任意精度整数运算包
01-15
虽然只是数据结构的课后习题，感觉也是个小型课程设计了
大整数高精度（包括四则运算，逻辑运算）
noi_beginner的博客
06-24 399
先上代码，后面再给注释 #include #include #include #include #include using namespace std; struct big{ char num[1000]; big(){ memset(num,0,sizeof(num)); } big value(const char *a){ memset(num,0,sizeof(num)); ...
刷题有感，java的大整数包运算
u013264213的博客
07-18 1011
今天刷题，碰到了一题关于大整数的题目，本来打算用c++写的，后来得知java的math包里包含很多大整数的运算，这样就可以了。于是决定用java来写。 题目是这样的： 给定三条边，请你判断一下能不能组成一个三角形。 输入描述: 输入包含多组数据，每组数据包含三个正整数a、b、c（1≤a, b, c≤10^100）。 输出描述: 对应每一组数据，如果它们能组成一个
大数运算
lala_lzw 的代码时间
06-13 632
大数运算使用string模拟 大整数运算包的设计与实现 （这里开扩充了一下打印大素数表） 1．问题描述 大整数运算是现代密码学算法实现的基础，重要性不言而喻。大整数我们指的是二进制位512、1024和2048的数，一般的语言不支持。 3．实现提示 在选择了大整数的存储结构之后，主要实现以下运算： ①模加 ②模减 ③模乘 ④模整除 ⑤模取余 ⑥幂模 ⑦GCD ⑧乘法逆 ⑨素数判定与生成 首先要定义大数类型 采用的是string，加bool表示符号来确定 class BigInt { public: bool
密码学课设-大整数运算包的设计与实现
Majula
03-19 1801
攻略指南实验描述实验分析类定义大数加法大数减法大数乘法大数整除大数取余编程实现 实验描述 问题描述 大整数运算是现代密码学算法实现的基础，重要性不言而喻。大整数我们指的是二进制位 512、1024 和 2048 的数，一般的语言不支持。 基本要求 以类库头文件的形式实现。 实现提示 在选择了大整数的存储结构之后，主要实现以下运算： 模加； 模减； 模乘； 模整除； 模取余。这五种运算模拟手算实现。 幂模：利用“平方-乘法”算法实现。 GCD：利用欧几里得算法实现。 乘法逆: 利用扩展的欧几里得
整数数组关于大整数包的设计！
weixin_34233679的博客
05-25 133
这两天一直在学习整数数组之类的问题,现在正好有机会和大家讨论一下.             C/C++中的int类型能表现的范围是-2E31－2E31–1。unsigned类型能表现的范围是0－2E32–1，即 0－4294967295。所以，int和unsigned类型变量，都不能保存超越10位的整数。有时我们须要介入运算的数，可能会远远不止10 位，例如，可能须要保存小数点前面100位（比如...
湖南科技大学 -- 密码学课程设计 -- 大整数包
Berserker____的博客
02-24 508
总共三个文件。 /* 文件名 Bignum.h */ #include <iostream> #include <cstdio> #include <string> #include <cstring> #include <vector> #include "FFT.h" #include "Vectorcal.h" using namespace std; struct Bignum { int s[2500];

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值