★ 引子

        前面两篇介绍了 Comba 乘法,最后提到当输入的规模很大时,所需的计算时间会急剧增长,因为 Comba 乘法的时间复杂度仍然是 O(n^2)。想要打破乘法中 O(n^2) 的限制,需要从一个完全不同的角度来看待乘法。在下面的乘法算法中,需要使用 x 和 y 这两个大整数的多项式基表达式 f(x) 和 g(x) 来表示。

令 f(x) = a * x + b,g(x) = c * x + d,h(x) = f(x) * g(x)。这里的 x 相当于一个基,比如十进制下,123456 可以表示成 123 * 100 + 456,这时 x 就是 100 了。

★ Karatsuba 乘法原理

         既然当输入规模 n 增加时计算量会以 n^2 增加,那么考虑使用分治的方式把一个规模较大的问题分解成若干个规模较小的问题,这样解决这几个规模较小的问题就会比较容易了。

对于 x 和 y 的乘积 z = x * y,可以把 x 和 y 都拆成两段:x 的左半段和右半段分别是 a 和 b,y 的左半段和右半段分别是 c 和 d。

现在考虑乘积 h(x) = f(x) * g(x):

h(x) = (a * x + b) * (c * x + d)

= a * c * (x^2) + (a * d + b * c) * x + b * d

可以看到,计算 h(x),需要计算 4 个一半大小的乘法,3 次加法,乘以 x 或者乘以 x^2 可以通过移位实现,所有的加法和移位共用 O(n) 次计算。

设 T(n) 是两个 n 位整数相乘所需的运算总数,则递归方程有:

T(n) =  4 * T(n / 2) + O(n)          当 n > 1

T(n) = O(1)                                       当 n = 1

解这个递归方程,得到 T(n) = O(n^2),即时间复杂度和 Comba 乘法是一样的,没有什么改进。要想降低计算的复杂度,必须减少乘法的计算次数。

注意到 a * d + b * c 可以用 a * c 和 b * d 表示: (a + b) * (c + d) - a * c - b * d。

原式 = (a + b) * (c + d) - a * c - b * d

= a * c + a * d + b * c + b * d - a *c - b *d

= a * d + b * c

上边的换算,说明计算 a * d + b * c 可以通过两次加法一次乘法搞定,这样总的乘法次数就减少到 3 次,列出新的递归方程有:

T(n) = 3 * T(n / 2) + O(n)         当 n > 1

T(n) = O(1)                                     当 n = 1

解递归方程得到 T(n) = O(n^log3),注意这里的 log 是以 2 为底,近似计算,时间复杂度为:T(n) = O(n^1.585),比 Comba 乘法的 O(n^2) 要小。

以上就是使用分治的方式计算乘法的原理。上面这个算法,由 Anatolii Alexeevitch Karatsuba 于1960年提出并于1962年发表,所以也被称为 Karatsuba 乘法。

★ 实现思路

原理弄明白了,现在整理一下思路:

1. 拆分输入:

计算分割的基:B = MIN(x->used, y->used) / 2

x0,y0 分别存储 x 和 y 的低半部分,x1,y1 分别存储 x 和 y 的高半部分。

2. 计算三个乘积:

x0y0 = x0 * y0           //递归调用乘法 bn_mul_bn

x1y1 = x1 * y1

t1 = x0 + x1

x0 = y0 + y1

t1 = t1 * x0

3. 计算中间项:

x0 = x0y0 + x1y1

t1 = t1 - x0

4. 计算最终乘积:

t1 = t1 * (2^(n * B))                    //左移 B个数位

x1y1 = x1y1 * (2^(2 * B))         //左移 2 * B 个数位

t1 = x0y0 + t1

z = t1 + x1y1                        //最终结果

★ 实现

         根据上面的思路,Karatsuba乘法的实现代码如下:

  1. static int bn_mul_karatsuba(bignum *z, const bignum *x, const bignum *y)
  2. {
  3. int ret;
  4. size_t i, B;
  5. register bn_digit *pa, *pb, *px, *py;
  6. bignum x0[1], x1[1], y0[1], y1[1], t1[1], x0y0[1], x1y1[1];
  7.  
  8. B = BN_MIN(x->used, y->used);
  9. B >>= 1;
  10.  
  11. BN_CHECK(bn_init_size(x0, B));
  12. BN_CHECK(bn_init_size(x1, x->used - B));
  13. BN_CHECK(bn_init_size(y0, B));
  14. BN_CHECK(bn_init_size(y1, y->used - B));
  15. BN_CHECK(bn_init_size(t1, B << 1));
  16. BN_CHECK(bn_init_size(x0y0, B << 1));
  17. BN_CHECK(bn_init_size(x1y1, B << 1));
  18.  
  19. x0->used = y0->used = B;
  20. x1->used = x->used - B;
  21. y1->used = y->used - B;
  22.  
  23. px = x->dp;
  24. py = y->dp;
  25. pa = x0->dp;
  26. pb = y0->dp;
  27.  
  28. for(i = 0; i < B; i++)
  29. {
  30. *pa++ = *px++;
  31. *pb++ = *py++;
  32. }
  33.  
  34. pa = x1->dp;
  35. pb = y1->dp;
  36.  
  37. for(i = B; i < x->used; i++)
  38. *pa++ = *px++;
  39.  
  40. for(i = B; i < y->used; i++)
  41. *pb++ = *py++;
  42.  
  43. bn_clamp(x0);
  44. bn_clamp(y0);
  45.  
  46. BN_CHECK(bn_mul_bn(x0y0, x0, y0));
  47. BN_CHECK(bn_mul_bn(x1y1, x1, y1));
  48.  
  49. BN_CHECK(bn_add_abs(t1, x0, x1));
  50. BN_CHECK(bn_add_abs(x0, y0, y1));
  51. BN_CHECK(bn_mul_bn(t1, x0, t1));
  52.  
  53. BN_CHECK(bn_add_abs(x0, x0y0, x1y1));
  54. BN_CHECK(bn_sub_abs(t1, t1, x0));
  55.  
  56. BN_CHECK(bn_lshd(t1, B));
  57. BN_CHECK(bn_lshd(x1y1, B << 1));
  58.  
  59. BN_CHECK(bn_add_abs(t1, x0y0, t1));
  60. BN_CHECK(bn_add_abs(z, t1, x1y1));
  61.  
  62. clean:
  63. bn_free(x0);
  64. bn_free(x1);
  65. bn_free(y0);
  66. bn_free(y1);
  67. bn_free(t1);
  68. bn_free(x0y0);
  69. bn_free(x1y1);
  70.  
  71. return ret;
  72. }

  

上面的代码,需要很多临时的 bignum 变量,但由于一开始就知道各个 bignum 的大小,所以使用 bn_init_size 函数初始化并且分配指定的数位,避免后面再进行内存的重新分配了,节约了时间。

算法一开始将输入的 x 和 y 拆分成两半,使用三个循环搞定。为了提高效率,这里在指针的前边加上了 register 关键字来暗示在执行过程中尽量把这几个指针变量放到 CPU 的寄存器中,以此来加快变量的访问速度。

乘法的操作是递归调用 bn_mul_bn 函数,这个是有符号数乘法的计算函数,后面会讲,当递归调用到某一个临界点后,乘法的计算会直接调用 Comba 方法进行计算,而不是一直使用 Karatsuba 递归下去。 bn_mul_bn 的函数原型是:int bn_mul_bn(bignum *z, const bignum *x, const bignum *y);

需要注意的是,每个计算操作(加法,减法,乘法和移位)在执行过程中都有可能出错,所以必须加上 BN_CHECK 宏进行错误检查,一旦函数调用出错,调到 clean 后面执行内存清理操作。

★ 分割点

虽然 Karatsuba 乘法执行时所需的单精度乘法比 Comba 方法少,但是也多了一项 O(n) 级别的开销来解一个方程组,用于计算中间项以及合并最后的结果,这就使得 Karatsuba 乘法在应对输入比较小的数字时所需的计算时间会更多。因此在实际操作中,递归计算到一定大小后,就应该改用 Comba 方法计算了。在 bn_mul_bn 函数中,分割点大小是 80(bn_digit 字长为 32 bit 时)或 64(bn_digit 字长为 64 bit 时),当输入两个数的规模有一个小于分割点时,就应该改用 Comba 方法计算乘法,只有当两个数的规模大于或等于分割点才使用 Karatsuba 方法递归计算。

★ 总结

Karatsuba 算法是比较简单的递归乘法,把输入拆分成 2 部分,不过对于更大的数,可以把输入拆分成 3 部分甚至 4 部分。拆分为 3 部分时,可以使用 Toom-Cook 3-way 乘法,复杂度降低到 O(n^1.465)。拆分为 4 部分时,使用 Toom-Cook 4-way 乘法,复杂度进一步下降到 O(n^1.404)。对于更大的数字,可以拆成 100 段,使用快速傅里叶变换,复杂度接近线性,大约是 O(n^1.149)。可以看出,分割越大,时间复杂度就越低,但是所要计算的中间项以及合并最终结果的过程就会越复杂,开销会增加,因此分割点上升,对于公钥加密,暂时用不到太大的整数,所以使用 Karatsuba 就合适了,不用再去弄更复杂的递归乘法。

下一篇将使用 Comba 方法和 Karatsuba 方法构建有符号数的乘法。

回到本系列目录

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

[转]大整数算法[11] Karatsuba乘法的更多相关文章

  1. 大整数算法[11] Karatsuba乘法

    ★ 引子         前面两篇介绍了 Comba 乘法,最后提到当输入的规模很大时,所需的计算时间会急剧增长,因为 Comba 乘法的时间复杂度仍然是 O(n^2).想要打破乘法中 O(n^2) ...

  2. 大整数算法[09] Comba乘法(原理)

    ★ 引子          原本打算一篇文章讲完,后来发现篇幅会很大,所以拆成两部分,先讲原理,再讲实现.实现的话相对复杂,要用到内联汇编,要考虑不同平台等等. 在大整数计算中,乘法是非常重要的,因为 ...

  3. 大整数算法[10] Comba乘法(实现)

    ★ 引子 上一篇文章讲了 Comba 乘法的原理,这次来讲讲如何实现.为了方便移植和充分发挥不同平台下的性能,暂时用了三种不同的实现方式: 1.单双精度变量都有的情况. 2.只有单精度变量的情况. 3 ...

  4. 大整数乘法(Comba 乘法 (Comba  Multiplication)原理)

    Comba 乘法以(在密码学方面)不太出名的 Paul G. Comba 得名.上面的笔算乘法,虽然比较简单, 但是有个很大的问题:在 O(n^2) 的复杂度上进行计算和向上传递进位,看看前面的那个竖 ...

  5. N!的阶乘附带简单大整数类的输入输出(暂时没有深入的了解)

    Given an integer N(0 ≤ N ≤ 10000), your task is to calculate N! 我的思路:就想着大整数类去了,才发现自己还不能很好的掌握,其实这是一个大 ...

  6. 从大整数乘法的实现到 Karatsuba 快速算法

    Karatsuba 快速乘积算法是具有独特合并过程(combine/merge)的分治算法(Karatsuba 是俄罗斯人).此算法主要是对两个整数进行相乘,并不适用于低位数(如 int 的 32 位 ...

  7. 【老鸟学算法】大整数乘法——算法思想及java实现

    算法课有这么一节,专门介绍分治法的,上机实验课就是要代码实现大整数乘法.想当年比较混,没做出来,颇感遗憾,今天就把这债还了吧! 大整数乘法,就是乘法的两个乘数比较大,最后结果超过了整型甚至长整型的最大 ...

  8. 算法笔记_034:大整数乘法(Java)

    目录 1 问题描述 2 解决方案 2.1 蛮力法   1 问题描述 计算两个大整数相乘的结果. 2 解决方案 2.1 蛮力法 package com.liuzhen.chapter5; import ...

  9. POJ 1001 解题报告 高精度大整数乘法模版

    题目是POJ1001 Exponentiation  虽然是小数的幂 最终还是转化为大整数的乘法 这道题要考虑的边界情况比较多 做这道题的时候,我分析了 网上的两个解题报告,发现都有错误,说明OJ对于 ...

随机推荐

  1. 第218天:Angular---模块和控制器

    1.使用NG实现双边数据绑定 所有需要ng管理的代码必须被包裹在一个有ng-app指令的元素中ng-app是ng的入口,表示当前元素的所有指令都会被angular管理(对每一个指令进行分析和操作) & ...

  2. Spring(1):Spring简介

    一句话概括: Spring是一种轻量级控制反转IoC和面向切面AOP的容器框架 初衷: 使用接口编程而不是类 为javabean提供一个更好的应用配置框架 javabean是一种规范而不是技术.是指符 ...

  3. PGM学习之三 朴素贝叶斯分类器(Naive Bayes Classifier)

    介绍朴素贝叶斯分类器的文章已经很多了.本文的目的是通过基本概念和微小实例的复述,巩固对于朴素贝叶斯分类器的理解. 一 朴素贝叶斯分类器基础回顾 朴素贝叶斯分类器基于贝叶斯定义,特别适用于输入数据维数较 ...

  4. UVA12538 Version Controlled IDE

    题意翻译 维护一种数据结构,资磁三种操作. 1.在p位置插入一个字符串s 2.从p位置开始删除长度为c的字符串 3.输出第v个历史版本中从p位置开始的长度为c的字符串 1≤n≤50000,所有字符串总 ...

  5. 用vim去掉utf-8 BOM

    '去掉utf-8 BOM :set nobomb '保留utf-8 BOM :set bomb

  6. 【BZOJ1079】【SCOI2008】着色方案

    Time Limit: 10 Sec Memory Limit: 162 MB Description 有n个木块排成一行,从左到右依次编号为1~n.你有k种颜色的油漆,其中第i种颜色的油漆足够涂ci ...

  7. NetApp常用巡检命令

    常用检查命令 environment status 查看环境信息 version 查看OS版本 sysconfig -v 查看系统信息(设备序列号 系统软.硬件信息等) sysconfig -a 查看 ...

  8. IO编程(2)-操作文件和目录

    操作文件和目录 如果我们要操作文件.目录,可以在命令行下面输入操作系统提供的各种命令来完成.比如dir.cp等命令. 如果要在Python程序中执行这些目录和文件的操作怎么办?其实操作系统提供的命令只 ...

  9. bug -- android 7.0 popwindow显示位置异常情况解决

    android 7.0 popwindow显示位置异常,在android7.1官方进行解决了,但是还是要多7.0的bug进行解决,我的解决方案里面通过重写popwindow进行适配: import a ...

  10. NOIWC2017&&THUWC2017 滚粗记

    因为NOI WC的时候一直在生病,浑浑噩噩就过去了7天,基本没什么记忆了,所以就压到一篇里好了. day -1 第一次发现高铁的椅子原来还可以转过来,于是我们四个小伙伴面对面愉快的打了一路宣红A. 在 ...