高精度运算

为了后面课程准备，先把基础的大数高精度运算先实现一遍。

为了后面课程准备，先把基础的大数高精度运算先实现一遍。

//BIGN.h

#ifndef BIGN_H
#define BIGN_H

#include <iostream>
#include <vector>
#include <string>
using namespace std;
const int MAXN = 3000;

//三元组gcd(a,b) = ax + by = d
struct gcd
{
    int x;
    int y;
    int d;
};


class bign
{
private:
    int n;   //参数n
    gcd m;   //定义一个三元组,使用欧几里得算法来进行递归求出最大公因子
public:
    //阶乘的精确值
    string factorial(int n);
    
    /**
     *注:由于我们研究的密码学群Z的范围在{0,1,2,....,n-1}当中
     *故下面的大数相加，大数相减，大数相乘并没有考虑出现负数的情况
     */

    //大数相加
    string add(string a,string b);

    //大数相减
    //默认s1>=s2,未处理负数情况
    string sub(string a,string b);

    //大数相乘
    //未考虑负数相乘的情况
    string mul(string a,string b);

    //返回一个十进制数的二进制长度
    int BitLength(int x);

    //返回x的二进制表示中从低到高的第i位
    int BitAt(int x,int i);

    //返回值:a^b mod n 的值
    //通过模重复平方法
    int Modular_Expoent(int a,int b,int n);

    //返回一个三元组
    gcd extended_Euclid(int a,int b);

    //模逆运算
    int inverse(int a,int m);
};

string bign::factorial(int n)
{
    string result;
    vector<long long> ff;
    ff.resize(MAXN);
    ff[0] = 1;
    int i,j;
    for(i = 2;i <= n;i++)
    {
        long long c = 0;
        for(j = 0;j < MAXN;j++)
        {
            long long s = ff[j] * i + c;   //模拟乘法的过程
            ff[j] = s % 10;
            c = s /10;
        }
    }
    for(j = MAXN - 1;j >= 0;j--)
    {
        if(ff[j])
            break;
    }
    for(i = j;i >= 0;i--)
    {
        result += (ff[i] + '0');
    }
    return  result;
}


string bign::add(string a,string b)
{
    string result;
    string rr;
    int i;
    int l1,l2,len1,len2;
    l1 = len1 = a.size();
    l2 = len2 = b.size();
    int aa,bb,cc,dd;
    dd = 0;
    while(l1 > 0 && l2 > 0)
    {
        aa = a[l1-1] - '0';
        bb = b[l2-1] - '0';
        cc = (aa + bb+dd) % 10;
        dd = (aa + bb+dd) / 10;
        result += cc+'0';
        l1--;
        l2--;
    }
    while(l1 > 0)
    {
        aa = a[l1-1] - '0';
        cc = (aa + dd) % 10;
        dd = (aa + dd) / 10;
        result += cc + '0';
        l1--;
    }
    while(l2 > 0)
    {
        bb = b[l2-1] - '0';
        cc = (bb + dd) % 10;
        dd = (bb + dd) / 10;
        result += cc + '0';
        l2--;
    }
    if(dd == 1)
        result += '1';
    for(i = result.size() - 1;i >= 0 ;i--)
        rr += result[i];
    return rr;
}

string bign::sub(string Max,string Min)
{
    string result;
    int lmax,lmin;
    lmax = Max.size();
    lmin = Min.size();
    int i,j,k;
    for(i = 0;i <= lmax;i++)
        result += '0';
    result[lmax] = '';
    lmax--;
    j = lmax;
    for(i = lmin - 1;i >= 0;i--,j--)
    {
        if(Max[j] - Min[i] >= 0)
        {
            result[j] = Max[j] - Min[i] + '0';
        }
        else
        {
            result[j] = 10 + Max[j] - Min[i] + '0';
            Max[j-1]--;
        }
    }
    while(Max[j] < 0)
    {
        Max[j] += 10;
        Max[j - 1]--;
        j--;
    }
    while(j >= 0)
    {
        result[j] = Max[j];
        j--;
    }
    return result;
}


string bign::mul(string aa,string bb)
{
    if(aa == "0" || bb == "0")
        return "0";
    else
    {
        string result;
        int i,j;
        int len1 = aa.size();
        int len2 = bb.size();
        for(i = 0,j = len1 - 1;i <= j;i++,j--)
        {
            char temp = aa[i];
            aa[i] = aa[j];
            aa[j] = temp;
        }
        for(i = 0,j = len2 - 1;i <= j;i++,j--)
        {
            char temp = bb[i];
            bb[i] = bb[j];
            bb[j] = temp;
        }
        vector<int> c;
        c.resize(MAXN);
        for(i = 0;i < len1;i++)
        {
            for(j = 0;j < len2;j++)
            {
                c[i+j] += (aa[i] - '0') * (bb[j] - '0');
            }
        }
        int k = len1 + len2;
        for(i = 0;i < k;i++)
        {
            if(c[i] > 9)
            {
                c[i+1] += c[i] / 10;
                c[i] %= 10;
            }
        }
        for(i = k - 1;i >= 0;i--)
        {
            if(c[i])
                break;
        }
        for(j = i;j >= 0;j--)
        {
            result += (c[j] + '0');
        }
        return result;
    }
}

int bign::BitLength(int x)
{
    int d = 0;
    while(x > 0)
    {
        x >>= 1;
        d++;
    }
    return d;
}

int bign::BitAt(int x,int i)
{
    return ( x & (1 << (i - 1)) );
}

int bign::Modular_Expoent(int a,int b,int n)
{
    int i,y = 1;
    for(i = BitLength(b);i > 0;i--)
    {
        y = (y * y) % n;
        if(BitAt(b,i) > 0)
            y = (y * a) % n;
    }
    return y;
}

gcd bign::extended_Euclid(int a,int b)
{
    gcd aa,bb;
    if(b == 0)
    {
        aa.x = 1;
        aa.y = 0;
        aa.d = a;
        return aa;
    }
    else
    {
        bb = extended_Euclid(b,a%b);
        aa.x = bb.y;
        aa.y = bb.x - (a / b) * bb.y;
        aa.d = bb.d;
    }
    return aa;
}

int bign::inverse(int a,int m)
{
    gcd aa;
    aa = extended_Euclid(a,m);
    return aa.x;
}
#endif