大整数包(简单版）

最新推荐文章于 2022-02-24 08:45:29 发布
最新推荐文章于 2022-02-24 08:45:29 发布
阅读量672 收藏 1
点赞数
分类专栏： 计算机程序语法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hengfanz/article/details/23453775
版权
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <limits>
#include <cstdlib>
using namespace std;
const int MAXD = 500, DIG = 9, BASE = 1000000000;
const unsigned long long BOUND = numeric_limits <unsigned long long> :: max () - (unsigned long long) BASE * BASE;
class bignum
{
    private:
         int digits[MAXD];
         int D;
    public:
    friend ostream &operator<<(ostream &out,bignum &c);
    inline void trim()
    {
           while(D > 1 && digits[D-1] == 0 )
               D--;
    }
    inline void dealint(long long x)
    {
           memset(digits,0,sizeof(digits));
           D=0;
           do
           {
                digits[D++]=x%BASE;
                x/=BASE;
           }
           while(x>0);
    }

    inline void dealstr(char *s)
    {
          memset(digits,0,sizeof(digits));
          int len = strlen(s),first = (len + DIG -1)%DIG + 1;
          D = (len+DIG-1)/DIG;
          for(int i = 0; i < first; i++)
              digits[D-1] = digits[D-1]*10 + s[i] - '0';
          for(int i = first, d = D-2; i < len; i+=DIG,d--)
              for(int j = i; j < i+DIG; j++)
                  digits[d] = digits[d]*10 + s[j]-'0';
          trim();
    }

    inline char *print()
    {
          trim(); 
          char *cdigits = new char[DIG * D + 1]; 
          int pos = 0,d = digits[D-1]; 
          do
          {
                cdigits[pos++] = d % 10 + '0';
                d/=10;
          }
          while(d > 0); 
          reverse(cdigits,cdigits+pos); 
          for(int i = D - 2; i >= 0; i--,pos += DIG)
              for(int j = DIG-1,t = digits[i]; j >= 0; j--)
              {
                    cdigits[pos+j] = t%10 + '0';
                    t /= 10;
              } 
        cdigits[pos] = '\0'; 
        return cdigits;
    } 
    bignum()
    {
        dealint(0);
    } 
    bignum(long long x)
    {
        dealint(x);
    } 
    bignum(int x)
    {
        dealint(x);
    } 
    bignum(char *s)
    {
        dealstr(s);
    } 
    inline bool operator < (const bignum &o) const
    {
        if(D != o.D)
            return D < o.D;

        for(int i = D-1; i>=0; i--)
            if(digits[i] != o.digits[i])
                return digits[i] < o.digits[i];
        return false; //equal

    } 
    bool operator >  (const bignum & o)const
    {
        return o < *this;
    }
    bool operator <= (const bignum & o)const
    {
        return !(o < *this);
    }
    bool operator >= (const bignum & o)const
    {
        return !(*this < o);
    }
    bool operator != (const bignum & o)const
    {
        return o < *this || *this < o;
    }
    bool operator == (const bignum & o)const
    {
        return !(o < *this) && !(*this < o);
    }
 
    bignum &operator++()
    {
        *this = *this  + 1;
        return *this;
    }
 
    bignum operator ++(int)
    {
        bignum old = *this;
        ++(*this);
        return old;
    } 
    inline bignum operator << (int p) const
    {
        bignum temp;
        temp.D = D + p;

        for (int i = 0; i < D; i++)
            temp.digits [i + p] = digits [i];

        for (int i = 0; i < p; i++)
            temp.digits [i] = 0;

        return temp;
    }

    inline bignum operator >> (int p) const
    {
        bignum temp;
        temp.D = D - p;

        for (int i = 0; i < D - p; i++)
            temp.digits [i] = digits [i + p];

        for (int i = D - p; i < D; i++)
            temp.digits [i] = 0;

        return temp;
    }
 
    bignum &operator += (const bignum &b)
    {
        *this = *this + b;
        return *this;
    }

    bignum &operator -= (const bignum &b)
    {
        *this = *this - b;
        return *this;
    }

    bignum &operator *= (const bignum &b)
    {
        *this = *this * b;
        return *this;
    }

    bignum &operator /= (const bignum &b)
    {
        *this = *this / b;
        return *this;
    }

    bignum &operator %= (const bignum &b)
    {
        *this = *this % b;
        return *this;
    }

    inline bignum operator + (const bignum &o) const
    {
        bignum sum = o;
        int carry = 0;

        for (sum.D = 0; sum.D < D || carry > 0; sum.D++)
        {
            sum.digits [sum.D] += (sum.D < D ? digits [sum.D] : 0) + carry;

            if (sum.digits [sum.D] >= BASE)
            {
                sum.digits [sum.D] -= BASE;
                carry = 1;
            }
            else
                carry = 0;
        }

        sum.D = max (sum.D, o.D);
        sum.trim ();
        return sum;
    }
    inline bignum operator - (const bignum &o) const
    {
        bignum diff = *this;

        for (int i = 0, carry = 0; i < o.D || carry > 0; i++)
        {
            diff.digits [i] -= (i < o.D ? o.digits [i] : 0) + carry;

            if (diff.digits [i] < 0)
            {
                diff.digits [i] += BASE;
                carry = 1;
            }
            else
                carry = 0;
        }

        diff.trim ();
        return diff;
    }
    inline bignum operator * (const bignum &o) const
    {
        bignum prod = 0;
        unsigned long long sum = 0, carry = 0;

        for (prod.D = 0; prod.D < D + o.D - 1 || carry > 0; prod.D++)
        {
            sum = carry % BASE;
            carry /= BASE;

            for (int j = max (prod.D - o.D + 1, 0); j <= min (D - 1, prod.D); j++)
            {
                sum += (unsigned long long) digits [j] * o.digits [prod.D - j];

                if (sum >= BOUND)
                {
                    carry += sum / BASE;
                    sum %= BASE;
                }
            }

            carry += sum / BASE;
            prod.digits [prod.D] = sum % BASE;
        }

        prod.trim ();
        return prod;
    }
    inline bignum range (int a, int b) const
    {
        bignum temp = 0;
        temp.D = b - a;

        for (int i = 0; i < temp.D; i++)
            temp.digits [i] = digits [i + a];

        return temp;
    }


    inline double double_div (const bignum &o) const
    {
        double val = 0, oval = 0;
        int num = 0, onum = 0;

        for (int i = D - 1; i >= max (D - 3, 0); i--, num++)
            val = val * BASE + digits [i];

        for (int i = o.D - 1; i >= max (o.D - 3, 0); i--, onum++)
            oval = oval * BASE + o.digits [i];

        return val / oval * (D - num > o.D - onum ? BASE : 1);
    }

    inline pair <bignum, bignum> divmod (const bignum &o) const
    {
        bignum quot = 0, rem = *this, temp;

        for (int i = D - o.D; i >= 0; i--)
        {
            temp = rem.range (i, rem.D);
            int div = (int) temp.double_div (o);
            bignum mult = o * div;

            while (div > 0 && temp < mult)
            {
                mult = mult - o;
                div--;
            }

            while (div + 1 < BASE && !(temp < mult + o))
            {
                mult = mult + o;
                div++;
            }

            rem = rem - (o * div << i);

            if (div > 0)
            {
                quot.digits [i] = div;
                quot.D = max (quot.D, i + 1);
            }
        }

        quot.trim ();
        rem.trim ();
        return make_pair (quot, rem);
    }

    inline bignum operator / (const bignum &o) const
    {
        return divmod (o).first;
    }

    inline bignum operator % (const bignum &o) const
    {
        return divmod (o).second;
    }


    inline bignum power (int exp) const
    {
        bignum p = 1, temp = *this;

        while (exp > 0)
        {
            if (exp & 1) p = p * temp;
            if (exp > 1) temp = temp * temp;
            exp >>= 1;
        }

        return p;
    }

    inline bignum factorial() const
    {
        bignum ans = 1, num = *this;

        if (num == 0 || num == 1)
            return ans;
        while (!(num < 0 || num == 0))
        {
            ans = ans * num;
            num = num - 1;
        }
        return ans;
    }
};

ostream &operator<<(ostream &out, bignum &c)
{
    out<<c.print();
    return out;
}

istream &operator >> (istream &in,bignum &c)
{
    char s[500];
    in>>s;
    c = s;
    return in;
}
bignum gcd(bignum a,bignum b)
{
    return b==0?a:gcd(b,a%b);
} 

franztao
关注
专栏目录
加减乘的大整数包
06-07
用c++程序实现了对大整数的加、减、 乘的运算，经测试，可行
关于大整数包的设计！
编程语言小筑
05-25 346
C/C++中的int类型能表示的范围是-2E31－2E31–1。unsigned类型能表示的范围是0－2E32–1，即 0－4294967295。所以，int和unsigned类型变量，都不能保存超过10位的整数。有时我们需要参与运算的数，可能会远远不止10 位，例如，可能需要保留小数点后面100位（比如求π的值），那么，即便使用能表示很大数值范围的double变量，但是由于double变...
大整数运算包
hengfanz的专栏
04-11 578
#include #include #include #include //#include #include using namespace std; #define max(a,b) (a)>(b)?(a):(b) #define min(a,b) (a) const int BIGN_MAXN=5000; const int bas
信息安全——大整数包的设计！
李树花开，风中摇曳
06-13 4219
大整数运算包的设计与实现 1．问题描述 大整数运算是现代密码学算法实现的基础，重要性不言而喻。大整数我们指的是二进制位512、1024和2048的数，一般的语言不支持。 2．基本要求 以类库头文件的形式实现。 3．实现提示    在选择了大整数的存储结构之后，主要实现以下运算： ①    模加； ②    模减； ③    模乘； ④    模整除； ⑤    模取余。这五种
大整数运算包的设计与实现
02-25
大整数的加法和减法相对简单，只需逐位进行，考虑进位或借位即可。乘法可以采用Karatsuba算法或Toom-Cook算法，这些分治算法能有效降低时间复杂度。除法则更为复杂，可能需要长除法或模幂运算等技术。 为了确保正确...
C++实现的大整数四则运算
12-25
3. **乘法**：可以采用Karatsuba算法或Toom-Cook算法等高效的乘法策略，或者简单地用两个大整数的每一位与另一个遍历相乘后累加。 4. **除法**：通常比乘法更复杂，可以使用长除法算法，逐位计算商和余数。 5. **...
精选_基于C++实现的大整数计算_源码打包
03-11
通过分析和学习这个源码包中的大整数计算实现，我们可以了解如何利用C++进行高效的算法设计，这对于开发高性能的软件系统至关重要。 在实际应用中，如密码学的RSA加密、区块链技术的椭圆曲线加密，或者大数据分析中...
大整数的运算
03-15
4. **加减乘除与指数运算**：大整数的加减法相对简单，只需要逐位比较并考虑进位。乘法可以使用Karatsuba算法或更高级的FFT（快速傅里叶变换）算法来提高效率。除法通常比加法和乘法复杂，可以采用长除法或基于模...
一个简单的大整数库文件
02-17
这里我们关注的是一份名为“一个简单的大整数库文件”的压缩包，其中包含两个文件：ULongInt.cpp 和 ULongInt.h。这两个文件很可能是实现大整数运算的C++源代码和头文件。下面我们将详细讨论大整数运算的基本概念、...
大整数包的设计与运算
04-23
程序主要有三个文件组成，一个主函数，一个大整数包函数的头文件（里面定义了大整数包运算符的重载，以及字符类型的转换），一个大整数包的cpp文件。
C语言实现的大整数基本运算库
11-11
该静态库包含大整数运算的基本操作，可以自己设置计算数的长度。目前该库只包含加减乘除，输入，输出和大数比较操作
任意精度整数运算包
01-15
虽然只是数据结构的课后习题，感觉也是个小型课程设计了
整数数组关于大整数包的设计！
weixin_34233679的博客
05-25 146
这两天一直在学习整数数组之类的问题,现在正好有机会和大家讨论一下.             C/C++中的int类型能表现的范围是-2E31－2E31–1。unsigned类型能表现的范围是0－2E32–1，即 0－4294967295。所以，int和unsigned类型变量，都不能保存超越10位的整数。有时我们须要介入运算的数，可能会远远不止10 位，例如，可能须要保存小数点前面100位（比如...
湖南科技大学 -- 密码学课程设计 -- 大整数包
Berserker____的博客
02-24 552
总共三个文件。 /* 文件名 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];
大整数运算包的实现（Java）(1) --加、减、乘、除、模取余、模加（考虑负数）
H_X_P_的博客
01-29 1711
大整数运算包的实现（Java）(1) --加、减、乘、除、模取余、模加（考虑负数）
大整数运算
摩尔的博客
08-23 633
A+B问题 对于A+B问题，当然如果A和B是属于int范围内的话，应该会轻松的解决。然而假若A和或者B是超过int范围的数字，那么就无法通过简单的加法来实现了，此类问题就是 大整数加法问题 解法：可通过字符串的形式先存储A和B（输入的顺序和存储的顺序要逆转），然后，再模拟加法的过程，最后再将结果打印出来即可。最难的莫过于模拟加法的过程了，不过理解了还是挺简单的代码#include<stdio.h>
大整数处理
u011164680的博客
12-07 350
输入：一个整数n(n可能很大) 输出：例如 n = 789 ; f(n) = 7+8+9 = 24; f(n) = 2+4 = 6;此时f(n)只有1位，输出f（n） 样例输入：4546313123 样例输出：5 def funcint(num): while len(str(num)) &amp;gt; 1: sum = 0 for i in s...
[00305]字节到大整数的打包与解包
语言小蛀虫
01-16 303
字节到大整数的打包与解包一、 解决问题 你有一个字节字符串并想将它解压成一个整数。或者，你需要将一个大整数转换为一个字节字符串 二、解决方案 int.from_bytes() / int.to_bytes() 三、代码说明#!/usr/bin/env python""" 使用场景： 密码管理，文件加密中，网络 """data = b'\x00\x124V\x00x\x90\xab\x
大整数乘法算法实现
"大整数乘法的实现代码示例" 大整数乘法是计算超过常规整型范围的大整数相乘的问题。在计算机科学中，特别是在算法和加密领域，处理大整数是非常常见的...然而，这个简单的例子对于理解大整数乘法的基本原理很有帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值