64位系统下通过前向进位实现快速加法

1、void cal()
核心部分，快速加法—前向进位。
2、void trans(int M, int N, char *X, int *result, int &resultLen)
大整数的任意进制转换程序。将M进制数*X转为为N进制数*result。还会得到*result的长度resultLen。
3、辅助函数：
void convert()
将最终得到的结果从二进制形式的整型数组转换为一个字符数组。
void print(int *result, int len)
将长度为len的整型数组result逆序打印
void print1(char *n)
将字符型数组n逆序打印

#include <stdio.h>
#include <string.h>

int dA[32], dB[32], dS[32];   //decimal 
int bA[64], bB[64], bS[64];   //binary

//defined in cla.pdf
char cS[65]; 
int hS[64];
int p[64], g[64];
int gg[16], gp[16];
int sg[4], sp[4], sc[4];
int gc[16];
int c[64];

//Faster Addition: Carry Lookahead 
//Steps for Calculation for 64 Bit CLA
void cal()
{
    int i, j, k;

    //step1
    for(i=0; i<64; i++)
    {
        g[i] = bA[i] & bB[i];
        p[i] = bA[i] | bB[i];
    }

    //step2
    for(j=0; j<16; j++)
    {
        i = j * 4;
        gg[j] = g[i+3] | (p[i+3] & g[i+2]) | (p[i+3] & p[i+2] & g[i+1]) | (p[i+3] & p[i+2] & p[i+1] & g[i]);
        gp[j] = p[i+3] & p[i+2] & p[i+1] & p[i];

    }

    //step3
    for(k=0; k<4; k++)
    {
        j = k * 4;
        sg[k] = gg[j+3] | (gp[j+3] & gg[j+2]) | (gp[j+3] & gp[j+2] & gg[j+1]) | (gp[j+3] & gp[j+2] & gp[j+1] & gg[j]);
        sp[k] = gp[j+3] & gp[j+2] & gp[j+1] & gp[j];
    }

    //step4
    sc[0] = sg[0];
    for(k=1; k<4; k++)
    {
        sc[k] = sg[k] | (sp[k] & sc[k-1]);
    }

    //step5
    gc[0] = gg[0];
    for(j=1; j<16; j++)
    {
        if((j+1) % 4 == 0)
        {
            int k = (j+1) / 4;
            gc[j] = sc[k] | gg[j] | (gp[j] & gc[j-1]);
        }
        else
        {
            gc[j] = gg[j] | (gp[j] & gc[j-1]);
        }
    }

    //step6
    c[0] = g[0];
    for(i=0; i<64; i++)
    {
        if((i+1) % 4 == 0)
        {
            int j = (i+1) / 4 - 1;
            c[i] = gc[j] | g[i] | (p[i] & c[i-1]);
        }
        else
        {
            c[i] = g[i] | (p[i] & c[i-1]);
        }
    }

    //step7
    bS[0] = bA[0] ^ bB[0];
    for(i=1; i<64; i++)
    {
        bS[i] = bA[i] ^ bB[i] ^ c[i-1];
    }
}

//Converts the binary number "bS" to a string "cS"
void convert()
{
    int i = 63;
    while(bS[i] == 0)
        --i;
    int k = 0;
    int j = i;
    for(; j>=0; j--)
    {
        char tmp[2];
        sprintf(tmp, "%d", bS[j]);
        cS[k] = tmp[0];
        k++;
    }
    cS[k] = '\0';
}

//Converts the "X" whose base is M to "result" whose base is N 
void trans(int M, int N, char *X, int *result, int *resultLen)
{
    int i;
    int k = 0;
    int len = strlen(X);  
    int data[100];
    for(i=0; i<len; i++)
    {  
        if('A' <= X[i] && X[i] <= 'Z')  
            data[i] = X[i] - 'A' + 10;  
        else if('a' <= X[i] && X[i] <= 'z') 
            data[i] = X[i] - 'a' + 10;
        else  
            data[i] = X[i] - '0';  
    }  

    int sum = 1;
    int d = 0;

    while(sum)
    {
        sum = 0;  
        for(i=0; i<len; i++)
        {  
            d = data[i] / N;  
            sum += d;  
            if(i == len-1)
            {  
                result[k++] = data[i] % N;  
            }  
            else
            {  
                data[i+1] += (data[i] % N) * M;  
            }  
            data[i] = d;  
        }  
    }

    if(k == 0)
    {  
        result[k] = 0;  
        k--;  
    }  
    if(k == -1)
    {  
        result[0] = 0;
        *resultLen = 1;
    }  
    else
    {  
        *resultLen = k;
    }  
}

//To print "result" whose length is "len" in reverse order
void print(int *result, int len)
{
    int i;
    for(i=0; i<len; i++)
    {  
        if(result[len-i-1] > 9)  
            printf("%c", (result[len-i-1] - 10 + 'a' ));  
        else  
            printf("%c", result[len-i-1] + '0');  
    } 
}

//To print the string "n" in reverse order
void print1(char *n)
{
    int len = strlen(n);
    int i;
    for(i=0; i<16-len; i++)
        printf("%d", 0);
    printf("%s", n);
}

int main()
{
  char cA[16], cB[16];
  memset(bA, 0, sizeof(bA));
  memset(bB, 0, sizeof(bB));
  memset(bS, 0, sizeof(bS));
  memset(dA, 0, sizeof(dA));
  memset(dB, 0, sizeof(dB));
  memset(dS, 0, sizeof(dS));
  memset(hS, 0, sizeof(hS));

  printf("Enter A (hex): ");
  scanf("%s", &cA);
  printf("Enter B (hex): ");
  scanf("%s", &cB);

  int lenA, lenB;
  trans(16, 10, cA, dA, &lenA);  //Converts hexadecimal to decimal.  cA-->dA
  trans(16, 10, cB, dB, &lenB);  //                                  cB-->dB
  printf("\nA is "); print1(cA); printf(" or "); print(dA, lenA);   //print cA dA
  printf("\nB is "); print1(cB); printf(" or "); print(dB, lenB);   //print cB dB

  printf("\n\nCalculate Sum, S:\n");

  trans(16, 2, cA, bA, &lenA);   //Converts hexadecimal to binary.   cA-->bA
  trans(16, 2, cB, bB, &lenB);   //                                  cB-->bB
  cal();    //Import! Faster Addition: Carry Lookahead.             bA + bB = bS
  printf("\nA (bin): ");  print(bA, 64);                            //print bA
  printf("\nB (bin): ");  print(bB, 64);                            //print bB
  printf("\nS (bin): ");  print(bS, 64);                            //print bS

  convert();  //Converts an array of integers  to a string.         bS-->cS
  int lenS, lenS1;
  trans(2, 10, cS, dS, &lenS);  //Converts a string to decimal.      cS-->dS
  trans(2, 16, cS, hS, &lenS1); //Converts a string to hexadecimal.  cS-->hS
  printf("\n\nS is "); print(hS, 16); printf(" or "); print(dS, lenS);  //print hS dS

  printf("\n\n");
  return 0;
}