大整数算法[10] Comba乘法（实现）

★ 引子

上一篇文章讲了 Comba 乘法的原理，这次来讲讲如何实现。为了方便移植和充分发挥不同平台下的性能，暂时用了三种不同的实现方式：

1、单双精度变量都有的情况。

2、只有单精度变量的情况。

3、可以使用内联汇编的情况。

前面已经介绍了 Comba 乘法的原理和实现思路，为了方便，再把它贴到这里：

计算 c = a * b，c0，c1，c2 为单精度变量。

1. 增加 c 到所需要的精度，并且令 c = 0，c->used = a->used + b->used。

2. 令 c2 = c1 = c0 = 0。

3. 对于 i 从 0 到 c->used - 1 循环，执行如下操作：

3.1 ty = BN_MIN(i, b->used - 1)

3.2 tx = i - ty

3.3 k = BN_MIN(a->used - tx, ty + 1)

3.4 三精度变量右移一个数位：(c2 || c1 || c0) = (0 || c2 || c1)

3.5 对于 j 从 0 到 k - 1 之间执行循环，计算：

(c2 || c1 || c0) = (c2 || c1 || c0) + a(tx + j) * b(ty - j)

3.6 c(i) = c0

4. 压缩多余位，返回 c。

上面所说的三种不同实现方式，主要体现在 3.5 中的循环。 Comba 乘法的实现代码如下：（暂时不考虑 x = x * y 这种输入和输出是同一个变量的情况）

static void bn_mul_comba(bignum *z, const bignum *x, const bignum *y)
{
    bn_digit c0, c1, c2;
    bn_digit *px, *py, *pz;
    size_t nc, i, j, k, tx, ty;
 
    pz = z->dp;
    nc = z->used;
 
    c0 = c1 = c2 = 0;
 
    for(i = 0; i < nc; i++)
    {
        ty = BN_MIN(i, y->used - 1);
        tx = i - ty;
        k = BN_MIN(x->used - tx, ty + 1);
 
        px = x->dp + tx;
        py = y->dp + ty;
 
        c0 = c1;
        c1 = c2;
        c2 = 0U;
 
        //Comba 32
        for(j = k; j >= 32; j -= 32)
        {
            COMBA_INIT
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
 
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
 
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
 
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_STOP
        }
        //Comba 16
        for(; j >= 16; j -= 16)
        {
            COMBA_INIT
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
 
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_STOP
        }
        //Comba 8
        for(; j >= 8; j -= 8)
        {
            COMBA_INIT
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_STOP
        }
        //Comba 4
        for(; j >= 4; j -= 4)
        {
            COMBA_INIT
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_MULADDC    COMBA_MULADDC
            COMBA_STOP
        }
        //Comba 1
        for(; j > 0; j--)
        {
            COMBA_INIT
            COMBA_MULADDC
            COMBA_STOP
        }
 
        *pz++ = c0;
    } //for i
 
    bn_clamp(z);
}

在 3.5 步中的内循环，乘法的计算按照 1，4，8，16，32 的步进展开，展开的过程需要比较大的空间，但是减少了循环控制的开销，所以可以节省大量时间。执行乘法的关键代码都定义在 COMBA_INIT，COMBA_MULADDC 和 COMBA_STOP 这三个宏内。COMBA_INIT 用于变量定义或者初始化，COMBA_MULADDC 用于计算单精度乘法和累加，COMBA_STOP 用于存储当前计算结果。另外，这里假设 z 的精度已经足够。

★ 单双精度变量都有的情况

这种情况下，因为 bn_digit 和 bn_udbl 同时有定义，所以是最容易实现的一种。三个宏的定义如下：

#define COMBA_INIT                                  \
{                                                   \
    bn_udbl r;                                      \
 
#define COMBA_MULADDC                               \
                                                    \
    r = (bn_udbl)(*px++) * (*py--) + c0;            \
    c0 = (bn_digit)r;                               \
    r = (bn_udbl)c1 + (r >> biL);                   \
    c1 = (bn_digit)r;                               \
    c2 += (bn_digit)(r >> biL);                     \
 
#define COMBA_STOP                                  \
}

在乘法器中，定义双精度变量 r 存储单精度乘法结果。在计算中，先计算单精度乘法，然后在与三精度变量 c2||c1||c0 相加。因为 c0，c1，c2 都是单精度数，为了避免溢出，先把累加计算的结果放到 r 上，然后提取低半部分作为当前数位的值。这里暂时不需要存储计算结果，所以 COMBA_STOP 没有什么操作。

★ 只有单精度变量的情况

这种情况下，bn_udbl 没有定义，每个数被拆成高半部分和低半部分，要执行 4 次单精度乘法，所以计算会比较复杂。

#define COMBA_INIT                                  \
{                                                   \
    bn_digit a0, a1, b0, b1;                        \
    bn_digit t0, t1, r0, r1;                        \
 
#define COMBA_MULADDC                               \
                                                    \
    a0 = (*px << biLH) >> biLH;                     \
    b0 = (*py << biLH) >> biLH;                     \
    a1 = *px++ >> biLH;                             \
    b1 = *py-- >> biLH;                             \
    r0 = a0 * b0;                                   \
    r1 = a1 * b1;                                   \
    t0 = a1 * b0;                                   \
    t1 = a0 * b1;                                   \
    r1 += (t0 >> biLH);                             \
    r1 += (t1 >> biLH);                             \
    t0 <<= biLH;                                    \
    t1 <<= biLH;                                    \
    r0 += t0;                                       \
    r1 += (r0 < t0);                                \
    r0 += t1;                                       \
    r1 += (r0 < t1);                                \
    c0 += r0;                                       \
    c1 += (c0 < r0);                                \
    c1 += r1;                                       \
    c2 += (c1 < r1);                                \
 
#define COMBA_STOP                                  \
}

a1，a0 分别存储 x 的高半部分和低半部分，b1，b0 分别存储 y 的高半部分和低半部分，这两个操作可以通过将 x 和 y 向左向右移动半个数位得到。biLH 前面提到过，这里在说一下：biLH 是每个数位的比特大小的一半。上面这个乘法计算比较复杂，所以我先讲讲原理。

设 f(x)，g(x) 分别表示单精度数 a 和 b，要计算 c = a * b。

a 和 b 用 f(x) 和 g(x) 表示：f(x) = a1 * x + a0，g(x) = b1 * x + b0，其中这里的 x 就是 2 ^ (n / 2)。

那么 h(x) = f(x) * g(x) = a1 * b1 * (x ^ 2) + (a1 * b0 + a0 * b1) * x + a0 * b0。这里默认 a0，a1，b0，b1 都是半精度的变量，所以他们的乘积可以用一个单精度变量存储。

令 t0 = a1 * b0 = p * x + q，t1 = a0 * b1 = r * x + s，r0 = a0 * b0，r1 = a1 * b1，其中 p，q，r，s 是半精度数，那么 h(x) 可以改写成：

h(x) = a1 * b1 * (x ^ 2) + (p * x + q + r * x + s) * x + a0 * b0

= a1 * b1 * (x ^ 2) + ((p + r) * x + (q + s)) * x + a0 * b0

= a1 * b1 * (x ^ 2) + (p + r) * (x ^ 2) + (q + s) * x + a0 * b0

= (a1 * b1 + p + r) * (x ^ 2) + (q + s) * x + a0 * b0

= (r1 + p + r) * (x ^ 2) + (q + s) * x + r0

所以，要计算 (r1 + p + r) * (x ^ 2)，需要提取 t0，t1 的高半部分和 r1 相加（因为 r1 和 p，r 都是同类项，所以直接计算 x^2 的系数即可）。计算剩余项 (q + s) * x 和 r0 的和，需要将 t0 和 t1 的低半部分提取出来，左移半个数位后和 r0 相加（r0 是单精度数，而 q 和 s 是半个精度的，乘以 x 要左移半个数位）。计算 (q + s) * x + r0 后结果可能会溢出，表明产生了进位，所以还要把进位要传递到 (r1 + p + r) * (x ^ 2)，最终乘积 c 就可以用 r0，r1 组成的双精度变量 r1||r0 表示。最后将乘积 c 和三精度变量 c2||c1||c0 累加即可。

★ 使用内联汇编的情况

注：本小节涉及到 x86 的汇编，如果对汇编不了解的话，可以跳过，免得浪费心情。对于 C 的内联汇编，细节暂时不说了，参考下面两篇文章：

【GCC 和 VC 的内联汇编】 https://github.com/1184893257/simplelinux/blob/master/inlineasm.md

【Linux 中 x86 的内联汇编】 http://www.ibm.com/developerworks/cn/linux/sdk/assemble/inline/

如果编译环境可以使用内联汇编，则使用汇编指令执行乘法会加快计算速度。由于我只接触过 x86 平台的汇编，所以暂时只考虑 x86 平台，ARM，PowerPC 或者 MIPS 之类的架构暂时不管。在 x86 环境下，需要考虑到 GCC 和 VC 环境下的内联汇编，毕竟他们的语法差别很大。

A. VC x86 环境下的内联汇编：（和 GCC 的比起来要简单得多）

#define COMBA_INIT                                  \
{                                                   \
    __asm   mov   esi, px                           \
    __asm   mov   edi, py                           \
 
#define COMBA_MULADDC                               \
                                                    \
    __asm   lodsd                                   \
    __asm   mov   ebx, [edi]                        \
    __asm   mul   ebx                               \
    __asm   add   c0,  eax                          \
    __asm   adc   c1,  edx                          \
    __asm   adc   c2,  0                            \
    __asm   sub   edi, 4                            \
 
#define COMBA_STOP                                  \
                                                    \
    __asm   mov   px, esi                           \
    __asm   mov   py, edi                           \
}

1. 首先把指针 px 和 py 的地址用 MOV 指令分别送到源变址寄存器 ESI 和目的变址寄存器 EDI。

2. 执行单精度乘法和累加：

A. 执行 LODSD 指令，把 ESI 寄存器指向的数据段中某单元的内容（也就是 x 的某个数位的值）送到 EAX 寄存器中，并根据方向标志和数据类型修改 ESI 寄存器的内容，具体的操作是将 ESI 中的地址增加 4，相当于 C 中的 px++。一般情况下，方向标志 DF = 0， ESI 中的地址增加。如果 DF = 1，要执行 CLD 指令把 DF 置为 0，不过一般情况下不会出现这种情况的。

B. 用 MOV 指令把 EDI 寄存器所指向的数据段中某单元的内容（也就是 y 的某个数位的值）送到 EBX 寄存器中。

C. 执行 MUL 指令执行单精度乘法：（EDX，EAX）= EAX * EBX，计算 EAX 和 EBX 的乘积，结果的高位放在 EDX 寄存器中，结果的低位放在 EAX 寄存器中。

D. 执行 ADD 加法指令，将乘积的低位累加到三精度变量的最低位 c0 上。

E. 执行 ADC 带进位的加法指令，将乘积的高位和上一步加法产生的进位累加到三精度变量的第二个数位 c1 上。

F. 执行 ADC 带进位的加法指令，将剩余的进位加到三精度变量的最高位 c2 上。

G. 执行 SUB 减法指令，将 EDI 中的地址往前挪 4 字节，相当于 C 中的 py--。

3. 存储计算结果：用 MOV 指令把 ESI 和 EDI 中的地址送回到指针 px 和 py 中，之所以要做这一步，是因为在循环中，循环控制可能会修改 CPU 寄存器的值，如果在计算结束后不存储 ESI 和 EDI 的地址值，那么地址可能就会因为寄存器被修改而丢失。

B. GCC x86 环境下的内联汇编：（比较复杂）

#define COMBA_INIT                                    \
{                                                     \
    asm                                               \
    (                                                 \
       "movl %5, %%esi       \n\t"                    \
       "movl %6, %%edi       \n\t"                    \
 
#define COMBA_MULADDC                                 \
                                                      \
       "lodsl                \n\t"                    \
       "movl (%%edi), %%ebx  \n\t"                    \
       "mull %%ebx           \n\t"                    \
       "addl %%eax, %2       \n\t"                    \
       "adcl %%edx, %3       \n\t"                    \
       "adcl $0, %4          \n\t"                    \
       "subl $4, %%edi       \n\t"                    \
 
#define COMBA_STOP                                    \
                                                      \
       "movl %%esi, %0       \n\t"                    \
       "movl %%edi, %1       \n\t"                    \
       :"=m"(px),"=m"(py),"=m"(c0),"=m"(c1),"=m"(c2)  \
       :"m"(px),"m"(py)                               \
       :"%eax","%ebx","%ecx","%edx","%esi","%edi"     \
    );                                                \
}

这段 GCC 的内联汇编指令和上面的 VC 内联汇编指令操作是一样的，只是语法不同而已，具体的语法请自行参考上面的资料或者 Google 搜索 :)

C. GCC x64 环境下的内联汇编：（和上面的 GCC x86 类似）【补充】

考虑到在 64 bit 的 GCC 编译器下，可以使用 x64 的内联汇编，所以又加了这一部分代码。GCC x64 环境下的内联汇编和 GCC x86 的比较类似，只是寄存器和指令有些不同。细节可以参考这里：http://www.dutor.net/index.php/2013/11/att-syntax-and-gcc-inlined-assembly/

#define COMBA_INIT                                    \
{                                                     \
    asm                                               \
    (                                                 \
       "movq %5, %%rsi       \n\t"                    \
       "movq %6, %%rdi       \n\t"                    \
 
#define COMBA_MULADDC                                 \
                                                      \
       "lodsq                \n\t"                    \
       "movq (%%rdi), %%rbx  \n\t"                    \
       "mulq %%rbx           \n\t"                    \
       "addq %%rax, %2       \n\t"                    \
       "adcq %%rdx, %3       \n\t"                    \
       "adcq $0, %4          \n\t"                    \
       "subq $8, %%rdi       \n\t"                    \
 
#define COMBA_STOP                                    \
                                                      \
       "movq %%rsi, %0       \n\t"                    \
       "movq %%rdi, %1       \n\t"                    \
       :"=m"(px),"=m"(py),"=m"(c0),"=m"(c1),"=m"(c2)  \
       :"m"(px),"m"(py)                               \
       :"%rax","%rbx","%rcx","%rdx","%rsi","%rdi"     \
    );                                                \
}

要注意的是：在 GCC x64 的环境下，bn_digit 是 64 bit的，也就是 8 个字节，所以执行完乘法后，py 的地址应该往前挪动 8 个字节，因此 COMBA_MULADDC 中最后的减法指令是把地址减去 8，而不是减 4。

★ 总结

Comba 乘法大概就讲这么多吧。由于 Comba 乘法的时间复杂度仍然是 O(n^2)，所以当输入的规模 n 越大时，所需的时间仍然会急剧增加。下一篇文章将讲讲如何使用分治的方式降低乘法的时间复杂度。

【回到本系列目录】

版权声明
原创博文，转载必须包含本声明，保持本文完整，并以超链接形式注明作者Starrybird和本文原始地址：http://www.cnblogs.com/starrybird/p/4441022.html

大整数算法[10] Comba乘法（实现）的更多相关文章

大整数算法[09] Comba乘法（原理）
★ 引子原本打算一篇文章讲完,后来发现篇幅会很大,所以拆成两部分,先讲原理,再讲实现.实现的话相对复杂,要用到内联汇编,要考虑不同平台等等. 在大整数计算中,乘法是非常重要的,因为 ...
大整数算法[11] Karatsuba乘法
★ 引子前面两篇介绍了 Comba 乘法,最后提到当输入的规模很大时,所需的计算时间会急剧增长,因为 Comba 乘法的时间复杂度仍然是 O(n^2).想要打破乘法中 O(n^2) ...
[转]大整数算法[11] Karatsuba乘法
★ 引子前面两篇介绍了 Comba 乘法,最后提到当输入的规模很大时,所需的计算时间会急剧增长,因为 Comba 乘法的时间复杂度仍然是 O(n^2).想要打破乘法中 O(n^2) ...
大整数乘法（Comba 乘法（Comba Multiplication）原理）
Comba 乘法以(在密码学方面)不太出名的 Paul G. Comba 得名.上面的笔算乘法,虽然比较简单, 但是有个很大的问题:在 O(n^2) 的复杂度上进行计算和向上传递进位,看看前面的那个竖 ...
N！的阶乘附带简单大整数类的输入输出（暂时没有深入的了解）
Given an integer N(0 ≤ N ≤ 10000), your task is to calculate N! 我的思路:就想着大整数类去了,才发现自己还不能很好的掌握,其实这是一个大 ...
【老鸟学算法】大整数乘法——算法思想及java实现
算法课有这么一节,专门介绍分治法的,上机实验课就是要代码实现大整数乘法.想当年比较混,没做出来,颇感遗憾,今天就把这债还了吧! 大整数乘法,就是乘法的两个乘数比较大,最后结果超过了整型甚至长整型的最大 ...
算法笔记_034:大整数乘法（Java）
目录 1 问题描述 2 解决方案 2.1 蛮力法 1 问题描述计算两个大整数相乘的结果. 2 解决方案 2.1 蛮力法 package com.liuzhen.chapter5; import ...
[大整数乘法] java代码实现
上一篇写的“[大整数乘法]分治算法的时间复杂度研究”,这一篇是基于上一篇思想的代码实现,以下是该文章的连接: http://www.cnblogs.com/McQueen1987/p/3348426. ...
从大整数乘法的实现到 Karatsuba 快速算法
Karatsuba 快速乘积算法是具有独特合并过程(combine/merge)的分治算法(Karatsuba 是俄罗斯人).此算法主要是对两个整数进行相乘,并不适用于低位数(如 int 的 32 位 ...

随机推荐

Delphi 写日志的类
unit uProgLog; interface uses Windows, SysUtils, SyncObjs; const C_LOG_LEVEL_TRACE = $; C_LOG_LEVEL_ ...
HDOJ(HDU) 1708 Fibonacci String
Problem Description After little Jim learned Fibonacci Number in the class , he was very interest in ...
Foundation Data Structure
LinkedList : /** * 考虑的比较的周全,并且包含了全部的情况,代码也不乱<b></b> * * @param index * 插入的位置 * @param c ...
[git] github 使用简单记录
前提 :1. 已有 github 账号.2. 已安装 git .3. 在 github 和本地 git 客户端交互秘钥.(这步我记得需要做,有点久远,不确定.) 正文: 下面是一个简单的例子.先在 ...
无需转化直接使用ESD映像文件安装系统简明教程
原版系统ISO镜像的sources文件夹中包含install.wim映像文件,将这个WIM文件“解压”(官方术语“Apply”)后,可以看到和C盘的目录完全相同,即为系统文件. 而官方提供的原版ESD ...
kindle paperwhite 使用说明
calibre,eink必备转换软件. easypub,lucida制作的软件,支持txt to epub:txt to mobi,可以实现目录. 售后电话:400 817 0100 正常的设计格式转 ...
js用for循环为对象添加事件并传递参数
var objArr = getObjArr(id); for(var i=0; i<objArr.length; i++){ var param=objArr.param ad ...
java异常面试常见题目
在Java核心知识的面试中,你总能碰到关于处理Exception和Error的面试题.Exception处理是Java应用开发中一个非常重要的方面,也是编写强健而稳定的Java程序的关键,这自然使它 ...
让IE6,7,8支持HTML5新标签的方法
很多网站对网页进行重构的时候,提高标签的语义性,在网页中大量使用了section,article,header等HTML5新标签.考虑到目前win7自带的IE浏览器版本是IE8,而IE8不支持HTML ...
web前端面试试题总结---css篇
CSS 介绍一下标准的CSS的盒子模型?低版本IE的盒子模型有什么不同的? (1)有两种, IE 盒子模型.W3C 盒子模型: (2)盒模型: 内容(content).填充(padding).边界(m ...

大整数算法[10] Comba乘法（实现）

大整数算法[10] Comba乘法（实现）的更多相关文章

随机推荐

热门专题