1024位大数运算（二）

最新推荐文章于 2020-06-25 21:45:53 发布
最新推荐文章于 2020-06-25 21:45:53 发布
阅读量606 收藏
点赞数
文章标签： delete function 算法 null div bi
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sherwinkoo/article/details/6490402
版权

//求模运算（调用除法）
int BigInt::Mod(_int64 X)
{
         unsigned int M = 0;
         this->Div(X,&M);
         return M;
}
//比较两个大数的大小（只用于比较两个同号的大数）
bool BigInt::Comp(BigInt BI)
{
           if(this->m_bSign == P)  //先比较长度，再由高向低位依次比较
           {
                    if(this->m_nLength > BI.m_nLength)
                             return true;
                    else if(this->m_nLength < BI.m_nLength)
                             return false;
                    else
                    {
                             int i= this->m_nLength;
                             while(this->m_nValue[i] == BI.m_nValue[i])
                                       i--;
                            if(this->m_nValue[i] > BI.m_nValue[i])
                                       return true;
                            else
                                       return false;
                    }
           }
          else
          {
                    if(this->m_nLength > BI.m_nLength)
                             return false;
                    else if(this->m_nLength < BI.m_nLength)
                             return true;
                    else
                    {
                             int i= this->m_nLength;
                             while(this->m_nValue[i] == BI.m_nValue[i])
                                         i--;
                             if(this->m_nValue[i] > BI.m_nValue[i])
                                         return false;
                             else
                                         return true;
                    }
         }
}

//加法
BigInt BigInt::Add(BigInt addend)
{
         BigInt Sum;
         //如果两数符号不同，调用减法
         if(this->m_bSign != addend.m_bSign )
         {
                 if(this->m_bSign == N)
                 {
                         this->m_bSign = P;
                         Sum = addend.Sub(*this);
                         this->m_bSign = N;
                  }
                 else
                {
                          addend.m_bSign = P;
                          Sum = this->Sub(addend);
                          addend.m_bSign = N;
                 }
                 return Sum;
       }
       //符号相同
       Sum.m_bSign = this->m_bSign ;
       Sum.m_nLength = (this->m_nLength > addend.m_nLength) ? this->m_nLength : addend.m_nLength;

       _int64 km = 0;
       bool carry = 0;  //进位标识
       for(int i=0; i<Sum.m_nLength; i++)
       {
                km = this->m_nValue[i] + addend.m_nValue[i] + carry;
                if(km > UPPERBOUND - 1)  //有进位
                {
                           carry = 1;
                           Sum.m_nValue[i] = km - UPPERBOUND;
                 }
                 else
                {
                            carry = 0;
                            Sum.m_nValue[i] = km;
                 }
  
       }
       if(carry)  //如果仍有进位，和的长度加一，并置一
       {
                Sum.m_nValue[i] = carry;
                Sum.m_nLength ++;
                if(Sum.m_nLength > MAXLENGTH)
                            cerr<<"overflow in add function!"<<endl;
       }
       return Sum;

}

//大数与32位无符号整型相加
void BigInt::Add(unsigned int addend)
{
         int  carry = 0;//进位标识
         _int64 km    = 0;
         km = this->m_nValue[0] + addend;
         if(km > UPPERBOUND - 1)//有进位
         {
                  carry = 1;
                  this->m_nValue[0] = km - UPPERBOUND;
         }
         else
         {
                   carry = 0;
                    this->m_nValue[0] = km;
                    return ;
         }
         //仍有进位,继续进行进位加
         for(int i=1; i < this->m_nLength && carry; i++)
         {
                    km = this->m_nValue[i] + carry;
                    if(km > UPPERBOUND - 1)
                    {
                             carry = 1;
                             this->m_nValue[0] = km - UPPERBOUND;
                     }
                     else
                     {
                             carry = 0;
                             this->m_nValue[0] = km;
                     }
         }
         if(carry)
         {
                  this->m_nValue[i] = carry;
                  this->m_nLength ++;
                  if(this->m_nLength > MAXLENGTH)
                              cout<<"overflow!"<<endl;
         }
}

BigInt BigInt::Sub(BigInt subtra)
{
        BigInt Diff;  //差
        //若符号不同调用加法函数
        if(this->m_bSign != subtra.m_bSign )
        {
                if(this->m_bSign == P)
                {
                        subtra.m_bSign = P;
                        Diff = this->Add(subtra);
                        subtra.m_bSign = N;
                }
                else
                {
                         subtra.m_bSign = N;
                         Diff = this->Add(subtra);
                         subtra.m_bSign = P;
                }
                return Diff;
       }
 
 
        if(this->Comp(subtra))  //被减数大于减数
        {
                 if(this->m_bSign == P) //同为正号
                 {
                         Diff.m_nLength = this->m_nLength;
                         _int64 km;
                         int carry = 0;
                         for(int i=0;i<Diff.m_nLength; i++)
                         {
                               //预先借位减
                              km = UPPERBOUND + this->m_nValue[i] - subtra.m_nValue[i] - carry;
                               if(km >= UPPERBOUND)  //不需要借位
                               {
                                    carry  = 0;
                                    km = km - UPPERBOUND; //将借来的再减去
                                }
                                else
                                         carry = 1;
                                Diff.m_nValue[i] = km; 
                         }
                 }
                 else  //同为负号，将被减数很减数都设置为正数，调用减法
                 {
                         this->m_bSign  = P;
                         subtra.m_bSign = P;
                         Diff = subtra.Sub(*this);  //减数减被减数
                         this->m_bSign = N;
                         subtra.m_bSign = N;
                 }
                 Diff.m_bSign = P;
          }
          else
          {
                  if(this->m_bSign == P)
                   {
                           Diff = subtra.Sub(*this);
                   }
                  else
                  {
                           this->m_bSign  = P;
                           subtra.m_bSign = P;
                           Diff = this->Sub(subtra);
                           this->m_bSign = N;
                           subtra.m_bSign = N;
                 }
                 Diff.m_bSign = N;
         }
 
        return Diff;
 
}

//大数乘法

BigInt BigInt::Mul(BigInt multiplier)
{
        BigInt Product;
        if(this->m_bSign == multiplier.m_bSign )
                 Product.m_bSign = P;
        else
                 Product.m_bSign = N;
        int i = multiplier.m_nLength - 1;
 //由乘数的高位开始乘，先将部分积移位（乘10），然后和乘数第i位与被乘数的积相加
        while(i>=0)
        {
               Product = Product.Mul(UPPERBOUND);
               Product = Product.Add(Mul(multiplier.m_nValue[i]));
               i--;
        }
        //积可达到的最长的位数
        Product.m_nLength = this->m_nLength + multiplier.m_nLength;
        if(Product.m_nValue[Product.m_nLength-1] == 0)
                  Product.m_nLength --;
        return Product;

}
//大数与64位无符号整型相乘（实际达不到64位）
BigInt BigInt::Mul(_int64 multiplier)
{
         BigInt Product;
         _int64 km;
         unsigned int carry = 0;  //进位
         Product.m_bSign = this->m_bSign;
         for(int i=0; i<this->m_nLength; i++)
         {
                 km = this->m_nValue[i] * multiplier + carry;
                 Product.m_nValue[i] = km % UPPERBOUND;  
                 carry = km /UPPERBOUND;
         }
         if(carry)
         {
                  Product.m_nValue[i] = carry;
                  Product.m_nLength = this->m_nLength + 1;
         }
         else
          {
                  Product.m_nLength = this->m_nLength;
          }
         return Product;

}
//除法
BigInt BigInt::Div(unsigned int X,unsigned int *M )
{
         BigInt result;
         result.m_nLength = this->m_nLength;
         result.m_bSign = this->m_bSign ;
         _int64 km = 0;
         //按竖式除法即可，km为上一位除得的余数
         for(int i=this->m_nLength-1; i>=0; i--)
         {  
                result.m_nValue[i] = (this->m_nValue[i]+km*UPPERBOUND)/X;
                km = (this->m_nValue[i]+km*UPPERBOUND)%X;
         }

        if( (result.m_nLength != 1) && (result.m_nValue[result.m_nLength-1] == 0) )
                 result.m_nLength --;
        if(this->m_bSign == N)
                km = 10 - km;
        if(M != NULL)
               *M = km;
        return result;
}
//幂的计算
BigInt BigInt::Power(BigInt index)
{

         BigInt Product;
         bool Sign = P;
         int k = 0;
         unsigned int M = 0;
         char* str = new char[index.m_nLength*8*4];//用来存放指数的二进制序列


         if(index.m_bSign == N)
         {
                  cerr<<"指数不可为负！"<<endl;
                  return Product;
         }
         if(this->EqulZero()&&index.EqulZero())
         {
                  cerr<<"底数和指数不可同时为零！"<<endl;
                  return Product;
         }

        if(index.Mod(2) == 1)  //指数为奇数
                  Sign = this->m_bSign;

         while( !index.EqulZero() )
         {
                index = index.Div(2,&M);
                str[k] = '0' + M;
                k++;
          }
         str[k] = '/0';
         k--;
         //下面是根据一个通用的求幂的快速算法
         if(str[k--] == '1')
                  Product.Set(*this);
         else 
                  Product.Set(1);
         for(int i= k; i>=0; i--)
         {
                  Product = Product.Mul(Product);
                  if(str[i] == '1')
                           Product = Product.Mul(*this);
         }
         Product.m_bSign = Sign;
         delete []str;
         return Product;
}

sherwinkoo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
大整数的基本运算
shengshengxiaowang的博客
07-30 642
写在前面： 大整数相加是很久之前写的，最近又写了大整数相乘，都不难，总结一下吧 如果以后写了大整数相除也会补充进来的。 众所周知，int型的范围为：-2147483648 ~ +2147483647 long long in型的范围为：-9223372036854775808 ~ +9223372036854775807 在现在这个大数据横行的时代，有些非常大的数据根本不够。 所以我们需要进行数据...
c语言实现1024bit大数乘法(3)
weixin_44830789的博客
05-17 1401
记录大数相乘的一般思路，乘法只是正数的大数相乘，数组第0位代表数组长度。 z[1]=x[1]*y[1] z[2]=x[1]*y[2] +x[2]*y[1] z[3]=x[1]*y[3] +x[2]*y[2]+x[3]*y[1] … 因此可得z[i]=x[i-j+1]*y[i], for j=1到 y[0]， x[0]> i-j>=0 考虑到进为问题，得到如下程序 Init(t); t[0] = x[0] + y[0] - 1; for (i = 1; i <=
大数取模运算y=g^a mod n 其中n为不小于1024比特的整数
10-01
给出一个高效程序计算模指数运算y=g^a mod n，其中n为不小于1024比特的整数
任意十进制大数乘法的C程序（字符界面）
08-11
在Unix或Linux平台实现 任意的两个无限大十进制数的乘法，并以字符界面显示。
RSA与大数运算
ruixj的专栏
07-13 6010
RSA与大数运算  http://www.pediy.com/ 雪凡 加密解密==========================================================================前言：此文来自于www.pediy.com一位Cracker---afanty之手。他建立了一个VC++（MFC）版的大数运算库。用Delphi的朋友们请到http://
易语言大数运算模块.ec
12-30
工具-支持库配置-数值计算支持库2.3版 需要勾选这个支持库，然后导入模块直接调用即可。
Java实现大数运算的实例代码
08-30
二、Java实现大数运算方法 在Java中，实现大数运算可以使用BigDecimal类，该类提供了高精度的数值计算功能。下面是一个简单的示例代码： import java.math.BigDecimal; class BigDecimalDemo { static final int...
大数运算c++
07-31
在C++编程语言中，处理大数运算是一项挑战，因为标准库提供的整型类型（如int、long long）无法应对超出其表示范围的大整数。为了解决这个问题，程序员通常会自定义数据结构和算法来实现大数运算。标题中的"大数运算...
大数运算 大数相加 大数相乘
07-18
在计算机科学中，大数运算是一项重要的计算...总的来说，大数运算在C/C++中涉及到了数组操作、位运算以及高级算法的应用，这对于理解和提升编程技巧非常有帮助。在处理大数据时，了解和掌握这些基础知识是至关重要的。
大数运算包含加，减，乘，除，取模，幂运算，模幂运算。支持十进制运算，二进制运算.zip
02-21
支持十进制运算，二进制运算.zip"文件中，我们可以预见到这可能是一个关于大数运算的程序或库，它不仅支持常见的十进制运算，还特别强调了二进制运算。 1. **大数运算**：大数运算通常在需要精确计算或处理大数据量...
C语言实现1024bit大数加法(1)
weixin_44830789的博客
05-13 2069
本来利用一般的思想的是一个数组位存一位数， 需要初始化数组a[1024]，但是可以利用更节省空间的方法。 C语言unsigned int 的范围是0-2^32-1,一个数组位就可以存32bit(1个int = 4Bytes = 4*8bit = 32 bit)， 1024比特用初始化数组a[1024/32]=a[32]可以储存完。在本程序中，我用a[0]代表实际数组的长度， 因此1024比特位的大数需要用数组a[33]存储。 bitmap思想 举一个例子 :其中0X代表16进制 a[33]...
RSA大数运算实现（1024位n）（5）蒙哥马利模幂
威化饼的一隅
02-11 5570
文章目录简介算法说明符号定义蒙哥马利模乘蒙哥马利模乘算法蒙哥马利约简REDC(T)算法效率代码实现REDC蒙哥马利模乘模幂运行结果 简介   在之前的（1）——（4）中，一步步地实现并优化了RSA及其大数运算库，之前说，RSA的效率取决于除法，是因为计算模幂，需要使用取模，取模使用除法，最后归根结底到了除法上。   然而，有另一种思路，就是在计算模幂时，使用蒙哥马利算法。蒙哥马利算法能够将取模时的...
C语言实现1024bit大数取模（5）
weixin_44830789的博客
05-19 1269
利用大数除法，很容易求模 /**************************************************************************************************** 大数求模 调用方式Mod(x,y,z) 返回值，z=x%y *****************************************************************************************************/ void Mod
RSA大数运算实现(1024位n) (1)
威化饼的一隅
12-08 1万+
RSA大数运算（1024位）综述数据结构和宏数据结构及宏bignum.h中的函数定义bignum.h中函数声明函数实现方法加法减法乘法乘法算法除法取模数论中的一些函数求最大公因子和求逆模幂运算费马素性检测中国剩余定理实现的数论函数位运算函数左移右移获得二进制位数实现的位运算函数特殊操作函数求前几十个素数的乘积，存在文件中产生指定二进制位数大随机数（利用SHA-1和rand()）寻找指定二进制位数素...
大数乘法——逐位与移位算法
Ni9htMar3的博客
04-07 4878
逐位相乘处理进位法 移位相乘处理进位法
非对称密码之DH密钥交换算法
热门推荐
Learning
12-13 1万+
1、DH算法的简介 DH，全称为“Diffie-Hellman”，他是一种确保共享KEY安全穿越不安全网络的方法，也就是常说的密钥一致协议。由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。 简单的说就是允许两名用户在公开媒体上交换信息以生成“一致”的、可以共享的密钥。也就是由甲方产出一对密钥（公钥、私钥），乙方依照甲方公钥产生乙方密钥对（公钥、私钥）。
乘法器
weixin_43727437的博客
06-25 7030
一、乘累加乘法器 对于n比特数，其二进制数转换为有符号十进制数的公式如下： 当B>=0，B的第n-1比特为0，则B可用下式表示： 设n=4，“5”的二进制为0101，则5=1 * 4 + 1 * 1 当B<0时，B的第n-1bit为1，B已为补码表示。 所以-|B|表示如下： 综上所述，有符号数与无符号数与十进制的转换表示可统一为如下格式： 对于正数或0，Bn-1=0； 对于负数，Bn-1=1 对于n比特无符号数： 最小数是： 0 最大数是2^n - 1 对于n比特有符号数： 最小数：-
RSA PKCS1padding 填充模式
liuxianbing119的专栏
03-29 1万+
在BouncyCastle实现RSA的PKCS1V1.5模式中，如果是公钥加密信息（forEncryption=true)，密钥长度为1024位，那么输出的密文块长度为128个字节，输入的明文块长度为127-10,即输入的明文块最大是117位，如果输入的明文块小于117位，比如输入的明文块长度为64位，那么会对这个明文块进行补位，在明文块前添加一位的0x02字节（代表公钥加密）然后后面的52位为随
配置开发支持高并发TCP连接的Linux应用程序全攻略
zys85的专栏
12-26 1062
1、修改用户进程可打开文件数限制   在Linux平台上，无论编写客户端程序还是服务端程序，在进行高并发TCP连接处理时，最高的并发数量都要受到系统对用户单一进程同时可打开文件数量的限制(这是因为系统为每个TCP连接都要创建一个socket句柄，每个socket句柄同时也是一个文件句柄)。可使用ulimit命令查看系统允许当前用户进程打开的文件数限制：   [speng@as4 ~]$ ulimi
openssl大数运算
最新发布
09-01
在OpenSSL中，大数运算是通过BIGNUM结构来实现的。BIGNUM是OpenSSL中用于表示大整数的数据类型。它提供了各种大数运算的函数，包括加法、减法、乘法、除法、模幂等。 要进行大数运算，首先需要创建BIGNUM对象，并...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值