NTT数论变换

最新推荐文章于 2024-01-25 13:17:08 发布
最新推荐文章于 2024-01-25 13:17:08 发布
阅读量1.4k 收藏 4
点赞数
分类专栏： 密码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxkhturfun/article/details/110522531
版权

下一篇：https://blog.csdn.net/wxkhturfun/article/details/111186205

1.参考链接

https://www.cnblogs.com/zarth/p/7288456.html
参考链接中给出的是c++代码，为了从头到尾理解一遍，在下用Python实现了一遍
需要注意的有：

  1. 整体代码与FFT(快速傅里叶变换)基本相仿
  2. 求逆的时候，即Fntt(a, n, -1)中的第三个参数为－1时，我们是乘上一个参数Inv，原理如下图：
    图片截自：https://zhuanlan.zhihu.com/p/80297169
    上图戴自：https://zhuanlan.zhihu.com/p/80297169
  3. 原作者用C字符串来处理输入，这里用Python列表来处理，差别在于最后一个字符’\0’，不过这没有影响，虽说一度纠结于此而影响改写
  4. 理论上python3的int型是无限长的（内存足够），但是还是得使用quick_mod函数，否则还是报错：溢出
  5. 如要想弄清所有的具体的蝶形运算原理、各个步骤的实现意义：https://zhuanlan.zhihu.com/p/80297169
    https://blog.csdn.net/GGN_2015/article/details/68922404
    6.阅读前，先阅读：链接…………从FTT到NTT

2.Python3 代码（魔改自C++）

给出与源码不同的另一组N P G NUM：

N = 256
P = 7681
G = 17
NUM = 9

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# author:ys
def quick_mod(a: int, b: int,m: int):
     ans = 1
     a %= m
     while(b):
          if(b & 1):
               ans = ans * a % m
               b-=1
          b >>= 1
          a = a * a % m
     return ans
def GetWn(NUM:int ,wn:list):
    for i in range(NUM):
        t = 1 << i
        wn[i] = quick_mod(G, int((P - 1) / t), P)
def Prepare(A:list, B:list, a:list ,b:list, length=1 ):
     length_A = len(A)
     length_B = len(B)
     while((length <= 2 * length_A) or (length <= 2 * length_B)):
          length <<= 1
     A.extend( [0]*(length - length_A) ) 
     B.extend( [0]*(length - length_B) ) 
     a.extend([0]*length)
     b.extend([0]*length)
     for i in range(length_A):
          A[length - 1 - i] = A[length_A - 1 - i]
     for i in range(length - length_A):
        A[i] = 0
     for i in range(length_B):
          B[length - 1 - i] = B[length_B - 1 - i]
     for i in range(length-length_B):
        B[i] = 0
     for i in range(length):
          a[length - 1 - i] = A[i]
     for i in range(length):
          b[length - 1 - i] = B[i]
     return length
def  Rader(a:list, length:int):
     j = length >> 1
     for i in range(1,length-1):
          if(i < j): 
               a[i], a[j] = a[j], a[i] 
          k = length >> 1
          while(j >= k):
               j -= k
               k >>= 1
          if(j < k):
               j += k
     #return a
def Fntt(a:list ,length:int ,on:int ):

     #a=Rader(a, length)
     Rader(a, length)
     id = 0
     h = 2
     while (h <= length): 
          id += 1
          for j in range(0,length,h):
               w = 1
               for k in range(j,j+int(h/2)):
                    u = a[k] % P
                    t = w * (a[k + int(h / 2)] % P) % P
                    a[k] = (u + t) % P
                    a[k + int(h / 2)] = ((u - t) % P + P) % P
                    w = w * wn[id] % P 
          h <<= 1             
     if(on == -1):
          for i in range(1,int(length/2)):
               a[i], a[length - i] = a[length - i],a[i]
          Inv = quick_mod(length, P - 2, P)
          for i in range(length):
               a[i] = a[i] % P * Inv % P
 
def Conv(a:list ,b:list ,n:int ):
     Fntt(a, n, 1)
     Fntt(b, n, 1)
     for i in range(n):
          a[i] = a[i] * b[i] % P
     Fntt(a, n, -1)
     
def Transfer(a:list ,n:list ):
     t = 0
     for i in range(n):
          a[i] += t
          if(a[i] > 9):
               t = int(a[i] / 10)
               a[i] %= 10
          else:
               t = 0
def Print (a:list, n:int):
     flag = True
     for i in range(n-1,-1,-1):
          if(a[i] != 0  and  flag):
               print( a[i],end="")
               flag = False
          elif( not flag):
               print(a[i],end="")
     print("")#这里的print是用于换行的需要，因为前面都是end=""

N = 1<<18
P = (479<<21) + 1
G = 3
NUM = 20
wn=[0]*NUM
GetWn(NUM,wn)
if __name__ == "__main__":
     nums = input("input:").split()
     A=[]
     B=[]
     for i in nums[0] :
          A.append(int(i))
     for i in nums[1] :
          B.append(int(i))
     a=[]
     b=[]
     length=Prepare(A, B,a,b,length=1)
     Conv(a,b,length)
     Transfer(a, length)
     Print(a,length)

3.简单测试

  1. 生成测试文件
import random
with open("fntt.txt","w") as f:
    for i in range(10000):
        A=random.randint(1000,9999)
        B=random.randint(1000,9999)
        result=A*B
        f.write(str(A)+"\t"+str(B)+"\t"+str(result)+"\n")

w代表覆盖，将“w”改为“a”则代表追加

  1. 测试
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# author:ys
def quick_mod(a: int, b: int,m: int):
     ans = 1
     a %= m
     while(b):
          if(b & 1):
               ans = ans * a % m
               b-=1
          b >>= 1
          a = a * a % m
     return ans
def GetWn(NUM:int ,wn:list):
    for i in range(NUM):
        t = 1 << i
        wn[i] = quick_mod(G, int((P - 1) / t), P)
def Prepare(A:list, B:list, a:list ,b:list, length=1 ):
     length_A = len(A)
     length_B = len(B)
     while((length <= 2 * length_A) or (length <= 2 * length_B)):
          length <<= 1
     A.extend( [0]*(length - length_A) ) 
     B.extend( [0]*(length - length_B) ) 
     a.extend([0]*length)
     b.extend([0]*length)
     for i in range(length_A):
          A[length - 1 - i] = A[length_A - 1 - i]
     for i in range(length - length_A):
        A[i] = 0
     for i in range(length_B):
          B[length - 1 - i] = B[length_B - 1 - i]
     for i in range(length-length_B):
        B[i] = 0
     for i in range(length):
          a[length - 1 - i] = A[i]
     for i in range(length):
          b[length - 1 - i] = B[i]
     return length
def  Rader(a:list, length:int):
     j = length >> 1
     for i in range(1,length-1):
          if(i < j): 
               a[i], a[j] = a[j], a[i] 
          k = length >> 1
          while(j >= k):
               j -= k
               k >>= 1
          if(j < k):
               j += k
     #return a
def Fntt(a:list ,length:int ,on:int ):

     #a=Rader(a, length)
     Rader(a, length)
     id = 0
     h = 2
     while (h <= length): 
          id += 1
          for j in range(0,length,h):
               w = 1
               for k in range(j,j+int(h/2)):
                    u = a[k] % P
                    t = w * (a[k + int(h / 2)] % P) % P
                    a[k] = (u + t) % P
                    a[k + int(h / 2)] = ((u - t) % P + P) % P
                    w = w * wn[id] % P 
          h <<= 1             
     if(on == -1):
          for i in range(1,int(length/2)):
               a[i], a[length - i] = a[length - i],a[i]
          Inv = quick_mod(length, P - 2, P)
          for i in range(length):
               a[i] = a[i] % P * Inv % P
 
def Conv(a:list ,b:list ,n:int ):
     Fntt(a, n, 1)
     Fntt(b, n, 1)
     for i in range(n):
          a[i] = a[i] * b[i] % P
     Fntt(a, n, -1)
     
def Transfer(a:list ,n:list ):
     t = 0
     for i in range(n):
          a[i] += t
          if(a[i] > 9):
               t = int(a[i] / 10)
               a[i] %= 10
          else:
               t = 0
def Print (a:list, n:int):
     flag = True
     result=""
     for i in range(n-1,-1,-1):
          if(a[i] != 0  and  flag):
               print( a[i],end="")
               result+=str(a[i])
               flag = False
          elif( not flag):
               print(a[i],end="")
               result+=str(a[i])
     #print("")
     return result

'''N = 1<<18
P = (479<<21) + 1
G = 3
NUM = 20'''
N = 1<<8
P = 257
G = 3
NUM = 20
wn=[0]*NUM
GetWn(NUM,wn)
if __name__ == "__main__":
     with open("fntt.txt","r") as f:
          sum=[0,0]
          for line in f.readlines():
               line = line.strip('\n')  #去掉列表中每一个元素的换行符
               nums = line.split()
               A=[]
               B=[]
               nttResult=""
               for i in nums[0] :
                    A.append(int(i))
               for i in nums[1] :
                    B.append(int(i))
               a=[]
               b=[]
               length=Prepare(A, B,a,b,length=1)
               Conv(a,b,length)
               Transfer(a, length)  
               print("A:"+nums[0]+"\t"+"B:"+nums[1]+"\t"+"result:"+nums[2]+"\t"+"FNTT:",end="") 
               nttResult=Print(a,length)
               if nttResult == nums[2]:
                    print("\tTrue")
                    sum[0]+=1
               else:
                    print("\tFalse")
                    sum[1]+=1
     accuracy=100*sum[0]/(sum[0]+sum[1])
     print("True:"+str(sum[0])+"\tFalse:"+str(sum[1])+"\t\t"+"Accuracy:",end="")
     print("%.2f%%" % accuracy)
Greate AUK
关注
专栏目录
比FFT还容易明白的NTT（快速数论变换）
路人黑的纸巾
08-17 3万+
NTTNTTNTT相关 一种快速数论变换算法，这种算法是以数论为基础，对样本点为的数论变换，按时间抽取的方法，得到一组等价的迭代方程，有效高速简化了方程中的计算公式·与直接计算相比，大大减少了运算次数。（见快速傅里叶变换）。 在计算机实现多项式乘法中，我们所熟知的快速傅里叶变换(FFT)是基于n次单位根 (omega) 的优秀性质实现的，而由于其计算时会使用正弦函数和余弦函数，在不...
【学习笔记】超简单的快速数论变换（NTT）（FFT的优化）（含全套证明）
繁凡さん的博客
12-28 5353
整理的算法模板合集： ACM模板 目录一、前置知识二、快速数论变换（NTT）三、NTT证明（和FFT的关系）四、NTT模板 点我看多项式全家桶(●’◡’●)（全家桶还没写完，待更链接hhh ） 一、前置知识 快速傅里叶变换FTT（学完FFT再看NTT哈，） 原根（链接待更，下面有原根的基础说明，足够今天的NTT使用了） 二、快速数论变换（NTT） 三、NTT证明（和FFT的关系） 我们发现FFT里的大多操作，都跟单位根没有什么关系，（例如选点插值，奇偶分治），我们随便选择一个n个点v,v2
[学习笔记]NTT——快速数论变换
weixin_34126557的博客
11-21 312
先要学会FFT[学习笔记]FFT——快速傅里叶变换 一、简介 FFT会爆精度。而且浮点数相乘常数比取模还大。 然后NTT横空出世了 虽然单位根是个好东西。但是，我们还有更好的东西我们先选择一个模数，$const\space int\space p=998244353$设g为p的单位根。这里就是3那么有：$(\omega_n^1)^n = g^{p-1}=1\space mod ...
数论变换Number Theoretic Transform(NTT）
Annalovecoding的博客
10-04 5903
数论变换是用来干什么的？ 数论变换是用来快速高效地计算系数为ZqZ_qZq​多项式环乘法运算结果的一个算法。 多项式定义 f(x)=∑i=0naixif(x)=\sum_{i=0}^{n}a_ix^if(x)=∑i=0n​ai​xi 多项式的根：f(x0)=0f(x_0)=0f(x0​)=0, x0x_0x0​为多项式的根 若an≠0,deg(f)=na_n \neq 0, deg(f) =nan​​=0,deg(f)=n 多项式乘法 f(x)=∑i=0naixif(x)=\sum_{i=0
NTT(快速数论变换)
lahlah的博客
04-23 1001
前置知识 法法踢（fft） 如果不懂FFT的可以先了解一下 NTT的作用 先扯淡一波
NTT快速数论变换
ruizhangj的博客
08-23 336
NTT NTTNTTNTT和FTTFTTFTT十分相似，在FTTFTTFTT中使用了单位复根ω\omegaω来取函数值，在NTTNTTNTT中则使用原根ggg来取函数值。在NTTNTTNTT中，所有的数都是模意义下的。 ggg​的一些性质 g1,g2,⋯ ,gp−1g^1,g^2,\cdots,g^{p-1}g1,g2,⋯,gp−1在模ppp意义下互不相同 根据欧拉定理可知gp−1≡1g^{p-1} \equiv 1gp−1≡1 用ggg来替换ω\omegaω实现FFTFFTFFT到NTTNTTNTT的
NTT.rar_NTT_NTT c++_NTT%20c%2B%2B_nttc++_快速数论变换
09-20
快速数论变换（Fast Number Theoretic Transform, NTT）是一种在数论背景下进行的高效算法，主要用于在有限域上进行大规模的线性运算，如乘法、卷积等。与快速傅里叶变换（FFT）类似，NTT在计算速度上具有显著优势，...
数论变换：此代码用于求一个序列的NTT-matlab开发
05-30
数论变换（Number-Theoretic Transform，NTT）是一种在数论背景下类似于快速傅里叶变换（Fast Fourier Transform，FFT）的算法。在数学和计算机科学中，NTT主要用于高效地处理模数上的多项式乘法。这个特定的代码是...
ntt:数论变换（NTT）
03-31
恩特 数论变换（NTT） 我在NTT进行试验的游乐场。
用python编写蝴蝶曲线的动画
12-21
关于turtle库，网上已经有了很多的知识和经验，这里不再赘述，仅仅说一下本人在学习中设计的一个蝴蝶动画，以供参考。 引入的库为： import turtle as pen import numpy as np 然后是对画图区域的设置： 包括： 标题 大小 隐藏画笔 screen = pen.getscreen() #获取pen的屏幕 screen.title("Python蝴蝶动画") #设置屏幕的标题 pen.screensize(500, 500, bg="grey") #设置绘图区和背景色 pen.shapesize(0.5,0.5,1)#设置画笔的比例，这里是没用的因为是
NTT（快速数论变换）学习
StaroForgin的博客
12-19 1379
NTT（快速数论变换） NTT是一个与FFT一样想看吐的算法，一个模板，调了一天。 关于FFT的部分我就不过多赘述了，可以参考这篇博客：~~~（还未完工）。 FFT虽然跑得快，但是因为是浮点数运算，终究还是有 精度、常数 等问题。 ------Tiw_Air_OAO 如上面那位巨佬所说，FFT的却存在许多问题，而且处理模数还比较麻烦于是就引入了 NTT，在——模的意义下（多项式的系...
fjut3283(NTT快速数论变换)
Soul
08-06 324
题解:我们将B序列反转那么最后就会变成 a0,a1,a2,.....an-1 b0,a1,b2......bn-1 那么答案将变成a0*bi+a1*bi-1+.....ai*b0+...+ai+1*bn-1+ai+2*bn-2+....an-1*bi+1然后你会发现答案就是多项式乘法,指数相加等于i的系数加上指数相加等于i+n的系数就是答案,因为这题数值较大用FFT可能会精度出现问题所以我们...
NTT快速数论变换算法学习
平凡人Kalzn的博客
08-31 937
前置知识 DFT离散傅里叶变换 原根 数学上已经证明，在复数域内，具有循环卷积特性的唯一变换是DFT，因此提出了以数论为基础的具有循环卷积性质的快速数论变换。 下面开始介绍NTT，快速数论变换 我们知道在复数域中有单位根：ωn=1\omega^n=1ωn=1，如果我们选取一个素数p，显然有ωn≡1(mod n)\omega^n\equiv1(mod\ n)ωn≡1(mod n)设g为p的一个原根（素数一定有原根，即gp−1≡1(mod p)g^{p-1}\equiv 1(mod
快速数论变换NTT
niiick
10-13 554
学习NTT首先需要一些前置知识，原根及其求解和FFT快速傅里叶变换 NTT与FFT的理论基础完全一样 FFT中求值与插值使用了n次单位根，而NTT则选择了原根 由此与FFT相比，NTT可以取模、避免浮点精度误差、且运算常数小 但也同时因此不能计算浮点系数，且模数也有限制 NTT的膜数一般是P=r2k+1P=r2^k+1P=r2k+1，常取P=998244353，其一个原根为g=3 可以证明，gP−1ng^{\frac{P-1}{n}}gnP−1​与wn=e2πinw_n=e^{\frac{2\pi i}{n
快速数论变换NTT学习笔记
我的技术栈碎碎念空间
01-25 1341
数论变换（number-theoretic transform, NTT）是离散傅里叶变换（DFT）在数论基础上的实现。NTT是一种计算卷积的快速算法，FFT也是其中一种。但是FFT具有一些实现上的缺点，举例来说，向量必须乘上复数系数的矩阵进行处理，而且每个复数系数的实部和虚部是一个正弦及余弦函数，因此大部分的系数都是浮点数，也就是说，必须做浮点复数运算，计算量会比较大，并且浮点数运算产生的误差会比较大。NTT解决的是多项式乘法带模数的情况，受到模数的限制，数也比较大。
NTT(快速数论变换）和多项式求逆学习小记
Cold_Chair的博客
04-13 1067
NTT类似于FFT，只是把单位复数根改成了具有特殊性质的数，当然是在mo意义下的。 假设是mo一个数p。 p一定要是一个质数，并且p-1 = 2^x*y，2^x次方还要比较大。 原根： 对于一个质数p，它一定有原根g。 满足g^x（mod p）意义下互不相同(0&lt;=x&lt;&lt;&lt;&lt;winwniw_n^i对应gi∗(mo−1)ngi∗(mo−1)ng^{i*{(...
matlab实现快速数论变换（NTT）
最新发布
08-21
快速数论变换（Fast Number Theoretic Transform，简称FFT），在MATLAB中通常用于处理离散傅立叶变换（Discrete Fourier Transform，DFT）的效率问题，尤其是在模意义下的DFT，即数论相关的应用。MATLAB提供了一套内置函数，如`fft`和`ifft`，以及针对特定需求优化的函数如`cconv`和`fftshift`，可以高效地计算NTT。 在MATLAB中，实现NTT的基本步骤包括： 1. **理解基础NTT**：了解基本的复数指数形式的NTT，它涉及到将数字序列映射到环Z/pZ上，其中p是一个素数。 2. **使用`ifft`或自定义算法**：对于大素数p，MATLAB的`ifft`函数实际上是通过Bluestein's algorithm或类似于其的变种来实现的NTT。如果需要更底层的控制，可以编写递归版本的NTT或基数r的循环移位法（Radix r FFT）。 3. **利用内置函数**：调用`fft`函数，并指定`'modular'`选项，可以得到模意义下的DFT，这本质上就是NTT。 4. **处理长度为p^n的序列**：如果需要处理长度不是质数幂的序列，可以先进行分块，然后对每个子块进行NTT，最后再组合结果。 ```matlab % 示例代码 prime = primes(100); % 获取一个小的素数集合 p = prime(1); % 选择一个素数 n = log2(p); seq = randi([0, p - 1], 1, p^n); % 随机生成一个长度为p^n的序列 % NTT ntt_result = ifft(seq, [], 'modulus', p); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Greate AUK

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值