LMMP 4.3.0
Lamina High-Precision Arithmetic Library
载入中...
搜索中...
未找到
toom_interp.h 文件参考
#include "impl/tmp_alloc.h"
#include "lmmp/lmmpn.h"
toom_interp.h 的引用(Include)关系图:
此图展示该文件被哪些文件直接或间接地引用了:

浏览该文件的源代码.

枚举

enum  toom6_flags { toom6_all_pos = 0 , toom6_vm1_neg = 1 , toom6_vm2_neg = 2 }
 Copyright (C) 2026 HJimmyK (Jericho Knox) 更多...
enum  toom7_flags { toom7_w1_neg = 1 , toom7_w3_neg = 2 }

函数

void lmmp_toom_couple_handling_ (mp_ptr pp, mp_size_t n, mp_ptr np, int nsign, mp_size_t off, int ps, int ns)
 Toom ± 点对配对混合:一次完成和/差半边的右移缩放与重叠拼回 (toom6h/8h 各评估点对的两个 (n+1) 位乘积的后处理) 输入 [pp,n] 与 (nsign ?
int lmmp_toom_eval_dgr3_pm1_ (mp_ptr xp1, mp_ptr xm1, mp_srcptr xp, mp_size_t n, mp_size_t x3n, mp_ptr tp)
 Toom-3 专用:3次多项式在 x = +1 和 x = -1 处求值 计算 P(+1) 和 P(-1),其中 P(x) 是一个3次多项式(4段系数)。
int lmmp_toom_eval_dgr3_pm2_ (mp_ptr xp2, mp_ptr xm2, mp_srcptr xp, mp_size_t n, mp_size_t x3n, mp_ptr tp)
 Toom-3 专用:3次多项式在 x = +2 和 x = -2 处求值 计算 P(+2) 和 P(-2),其中 P(x) 是一个3次多项式(4段系数)。
int lmmp_toom_eval_pm1_ (mp_ptr xp1, mp_ptr xm1, unsigned k, mp_srcptr xp, mp_size_t n, mp_size_t hn, mp_ptr tp)
 通用高阶 Toom 求值:k次多项式在 x = +1 和 x = -1 处求值
int lmmp_toom_eval_pm2_ (mp_ptr xp2, mp_ptr xm2, unsigned k, mp_srcptr xp, mp_size_t n, mp_size_t hn, mp_ptr tp)
 通用高阶 Toom 求值:k次多项式在 x = +2 和 x = -2 处求值
int lmmp_toom_eval_pm2exp_ (mp_ptr xp2, mp_ptr xm2, unsigned k, mp_srcptr xp, mp_size_t n, mp_size_t hn, unsigned shift, mp_ptr tp)
 通用高阶 Toom 求值:k次多项式在 x = +2^shift 和 x = -2^shift 处求值 (toom6h 的 ±4 / toom8h 的 ±4、±8 点)
int lmmp_toom_eval_pm2rexp_ (mp_ptr rp, mp_ptr rm, unsigned q, mp_srcptr ap, mp_size_t n, mp_size_t t, unsigned s, mp_ptr ws)
 通用高阶 Toom 求值:q次多项式在 x = +1/2^s 和 x = -1/2^s 处求值, 结果放大 2^(s*q)(toom6h 的 ±1/2、±1/4 / toom8h 的 ±1/2、±1/4、±1/8 点)
void lmmp_toom_interp12_ (mp_ptr dst, mp_ptr r1, mp_ptr r3, mp_ptr r5, mp_size_t n, mp_size_t spt, int half, mp_ptr tp)
 Toom插值计算(12点插值):用于 Toom-6.5(toom6h/toom6 平方)乘法 评估点:inf(仅 half), ±4, ±2, ±1, ±1/2, ±1/4, 0
void lmmp_toom_interp16_ (mp_ptr dst, mp_ptr r1, mp_ptr r3, mp_ptr r5, mp_ptr r7, mp_size_t n, mp_size_t spt, int half, mp_ptr tp)
 Toom插值计算(16点插值):用于 Toom-8.5(toom8h/toom8 平方)乘法 评估点:inf(仅 half), ±8, ±4, ±2, ±1, ±1/2, ±1/4, ±1/8, 0
void lmmp_toom_interp5_ (mp_ptr dst, mp_ptr v2, mp_ptr vm1, mp_size_t n, mp_size_t spt, int vm1_neg, mp_limb_t vinf0)
 Toom插值计算(5点插值),用于Toom-33和Toom-42乘法算法
void lmmp_toom_interp6_ (mp_ptr dst, mp_size_t n, enum toom6_flags flags, mp_ptr w4, mp_ptr w2, mp_ptr w1, mp_size_t w0n)
 Toom插值计算(6点插值):用于Toom-43和Toom-52 乘法算法
void lmmp_toom_interp7_ (mp_ptr dst, mp_size_t n, enum toom7_flags flags, mp_ptr w1, mp_ptr w3, mp_ptr w4, mp_ptr w5, mp_size_t w6n, mp_ptr tp)
 Toom插值计算(7点插值):用于Toom-44、Toom-53、Toom-62 乘法算法

枚举类型说明

◆ toom6_flags

Copyright (C) 2026 HJimmyK (Jericho Knox)

This file is part of LMMP.

LMMP is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library. If not, see https://www.gnu.org/licenses/.

SPDX-License-Identifier: LGPL-3.0-or-later

枚举值
toom6_all_pos 0 
toom6_vm1_neg 1 
toom6_vm2_neg 2 

在文件 toom_interp.h 第 29 行定义.

@ toom6_vm2_neg
@ toom6_vm1_neg
@ toom6_all_pos

◆ toom7_flags

枚举值
toom7_w1_neg 1 
toom7_w3_neg 2 

在文件 toom_interp.h 第 31 行定义.

31{ toom7_w1_neg = 1, toom7_w3_neg = 2 };
@ toom7_w1_neg
@ toom7_w3_neg

函数说明

◆ lmmp_toom_couple_handling_()

void lmmp_toom_couple_handling_ ( mp_ptr pp,
mp_size_t n,
mp_ptr np,
int nsign,
mp_size_t off,
int ps,
int ns )

Toom ± 点对配对混合:一次完成和/差半边的右移缩放与重叠拼回 (toom6h/8h 各评估点对的两个 (n+1) 位乘积的后处理) 输入 [pp,n] 与 (nsign ?

Copyright (C) 2026 HJimmyK (Jericho Knox)

-[np,n] : [np,n]),计算: [np,n] <- ([pp,n]+[np,n])/2^(ns+1)(和半边,供奇系数插值) [pp,n] <- ([pp,n]-[np,n])/2^(ps+1)(差半边,供偶系数) 最后 {pp,n+off} <- {pp,n} + {np,n}*B^off

参数
pp输入/输出:正点值乘积(容量 n+off+1 limbs)
n有效数据长度
np输入/输出:负点值乘积(容量 n limbs)
nsignnp 的符号(非 0 表示 np 存的是负值)
off拼回偏移(limb 数,0<=off<n)
ps和半边附加右移位数
ns差半边附加右移位数
警告
0<=off<n, ps>=0, ns>=0, pp/np 数据低 ps+1/ns+1 位保证为 0

Toom ± 点对配对混合:一次完成和/差半边的右移缩放与重叠拼回 (toom6h/8h 各评估点对的两个 (n+1) 位乘积的后处理) 输入 [pp,n] 与 (nsign ?

This file is part of LMMP.

LMMP is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library. If not, see https://www.gnu.org/licenses/.

SPDX-License-Identifier: LGPL-3.0-or-later

在文件 mul_toom_couple.c 第 26 行定义.

26 {
27 mp_limb_t cy;
28
30 lmmp_param_assert(off < n);
31 lmmp_param_assert(ps >= 0 && ns >= 0);
32
33 if (nsign)
34 lmmp_shr1sub_n_(np, pp, np, n);
35 else
36 lmmp_shr1add_n_(np, pp, np, n);
37
38 if (ps == 1)
39 lmmp_shr1sub_n_(pp, pp, np, n);
40 else {
41 lmmp_sub_n_(pp, pp, np, n);
42 if (ps > 0)
43 lmmp_shr_(pp, pp, n, ps);
44 }
45 if (ns > 0)
46 lmmp_shr_(np, np, n, ns);
47
48 pp[n] = lmmp_add_n_(pp + off, pp + off, np, n - off);
49 cy = lmmp_add_1_(pp + n, np + n - off, off, pp[n]);
50 lmmp_debug_assert(cy == 0);
51}
#define lmmp_debug_assert(x)
定义 lmmp.h:498
uint64_t mp_limb_t
定义 lmmp.h:92
#define lmmp_param_assert(x)
定义 lmmp.h:509
mp_limb_t lmmp_shr1add_n_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n)
加法后右移1位 [dst,n] = ([numa,n] + [numb,n]) >> 1
定义 shr.c:65
static mp_limb_t lmmp_add_1_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_limb_t x)
加单精度数静态内联函数 [dst,na]=[numa,na]+x
mp_limb_t lmmp_shr_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t shr)
右移操作 [dst,na] = [numa,na]>>shr,dst的高shr位填充0
定义 shr.c:26
mp_limb_t lmmp_sub_n_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n)
无借位的n位减法 [dst,n] = [numa,n] - [numb,n]
定义 sub_n.c:84
mp_limb_t lmmp_shr1sub_n_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n)
减法后右移1位 [dst,n] = ([numa,n] - [numb,n]) >> 1
定义 shr.c:87
mp_limb_t lmmp_add_n_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n)
无进位的n位加法 [dst,n] = [numa,n] + [numb,n]
定义 add_n.c:76
#define n

引用了 lmmp_add_1_(), lmmp_add_n_(), lmmp_debug_assert, lmmp_param_assert, lmmp_shr1add_n_(), lmmp_shr1sub_n_(), lmmp_shr_(), lmmp_sub_n_(), lmmp_toom_couple_handling_() , 以及 n.

被这些函数引用 lmmp_mul_toom6h_(), lmmp_mul_toom8h_(), lmmp_sqr_toom6_(), lmmp_sqr_toom8_() , 以及 lmmp_toom_couple_handling_().

函数调用图:
这是这个函数的调用关系图:

◆ lmmp_toom_eval_dgr3_pm1_()

int lmmp_toom_eval_dgr3_pm1_ ( mp_ptr xp1,
mp_ptr xm1,
mp_srcptr xp,
mp_size_t n,
mp_size_t x3n,
mp_ptr tp )

Toom-3 专用:3次多项式在 x = +1 和 x = -1 处求值 计算 P(+1) 和 P(-1),其中 P(x) 是一个3次多项式(4段系数)。

Copyright (C) 2026 HJimmyK (Jericho Knox)

参数
xp1输出:P(+1) 的结果(n+1 个 limb)
xm1输出:P(-1) 的结果(n+1 个 limb)
xp输入:多项式系数数组(共4段,每段 n limbs)
n每段完整系数的 limb 长度
x3n最后一段系数的实际长度(通常等于 n)
tp临时缓存空间(至少 n+1 limbs)
警告
0<x3n<=n, xp1!=NULL, xm1!=NULL, xp!=NULL, tp!=NULL
返回
符号位:0=正,~0=负(对应 P(-1))

Toom-3 专用:3次多项式在 x = +1 和 x = -1 处求值 计算 P(+1) 和 P(-1),其中 P(x) 是一个3次多项式(4段系数)。

This file is part of LMMP.

LMMP is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library. If not, see https://www.gnu.org/licenses/.

SPDX-License-Identifier: LGPL-3.0-or-later

在文件 mul_toom_eval.c 第 28 行定义.

28 {
29 int neg;
30 lmmp_param_assert(x3n > 0);
31 lmmp_param_assert(x3n <= n);
32
33 xp1[n] = lmmp_add_n_(xp1, xp, xp + 2 * n, n);
34 tp[n] = lmmp_add_(tp, xp + n, n, xp + 3 * n, x3n);
35
36 neg = (lmmp_cmp_(xp1, tp, n + 1) < 0) ? ~0 : 0;
37 if (neg)
38 lmmp_add_n_sub_n_(xp1, xm1, tp, xp1, n + 1);
39 else
40 lmmp_add_n_sub_n_(xp1, xm1, xp1, tp, n + 1);
41
42 lmmp_debug_assert(xp1[n] <= 3);
43 lmmp_debug_assert(xm1[n] <= 1);
44
45 return neg;
46}
static mp_limb_t lmmp_add_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_srcptr numb, mp_size_t nb)
加法静态内联函数 [dst,na]=[numa,na]+[numb,nb]
int lmmp_cmp_(mp_srcptr numa, mp_srcptr numb, mp_size_t n)
比较函数
定义 cmp.c:26
mp_limb_t lmmp_add_n_sub_n_(mp_ptr dsta, mp_ptr dstb, mp_srcptr numa, mp_srcptr numb, mp_size_t n)
同时执行n位加法和减法 ([dsta,n],[dstb,n]) = ([numa,n]+[numb,n],[numa,n]-[numb,n])
#define xp
#define tp

引用了 lmmp_add_(), lmmp_add_n_(), lmmp_add_n_sub_n_(), lmmp_cmp_(), lmmp_debug_assert, lmmp_param_assert, lmmp_toom_eval_dgr3_pm1_(), n, tp , 以及 xp.

被这些函数引用 lmmp_mul_toom43_(), lmmp_mul_toom44_(), lmmp_mul_toom6h_(), lmmp_mul_toom8h_(), lmmp_sqr_toom4_() , 以及 lmmp_toom_eval_dgr3_pm1_().

函数调用图:
这是这个函数的调用关系图:

◆ lmmp_toom_eval_dgr3_pm2_()

int lmmp_toom_eval_dgr3_pm2_ ( mp_ptr xp2,
mp_ptr xm2,
mp_srcptr xp,
mp_size_t n,
mp_size_t x3n,
mp_ptr tp )

Toom-3 专用:3次多项式在 x = +2 和 x = -2 处求值 计算 P(+2) 和 P(-2),其中 P(x) 是一个3次多项式(4段系数)。

参数
xp2输出:P(+2) 的结果(n+1 个 limb)
xm2输出:P(-2) 的结果(n+1 个 limb)
xp输入:多项式系数数组(共4段,每段 n limbs)
n每段完整系数的 limb 长度
x3n最后一段系数的实际长度
tp临时缓存空间(至少 n+1 limbs)
警告
0<x3n<=n, xp2!=NULL, xm2!=NULL, xp!=NULL, tp!=NULL
返回
符号位:0=正,~0=负(对应 P(-2))

在文件 mul_toom_eval.c 第 48 行定义.

48 {
49 mp_limb_t cy;
50 int neg;
51 lmmp_param_assert(x3n > 0);
52 lmmp_param_assert(x3n <= n);
53 /* (x0 + 4 * x2) +/- (2 x1 + 8 x_3) */
54
55 cy = lmmp_shl_(tp, xp + 2 * n, n, 2);
56 xp2[n] = cy + lmmp_add_n_(xp2, tp, xp, n);
57
58 tp[x3n] = lmmp_shl_(tp, xp + 3 * n, x3n, 2);
59 if (x3n < n)
60 tp[n] = lmmp_add_(tp, xp + n, n, tp, x3n + 1);
61 else
62 tp[n] += lmmp_add_n_(tp, xp + n, tp, n);
63
64 lmmp_shl_(tp, tp, n + 1, 1);
65
66 neg = (lmmp_cmp_(xp2, tp, n + 1) < 0) ? ~0 : 0;
67
68 if (neg)
69 lmmp_add_n_sub_n_(xp2, xm2, tp, xp2, n + 1);
70 else
71 lmmp_add_n_sub_n_(xp2, xm2, xp2, tp, n + 1);
72
73 lmmp_debug_assert(xp2[n] < 15);
74 lmmp_debug_assert(xm2[n] < 10);
75
76 return neg;
77}
mp_limb_t lmmp_shl_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t shl)
左移操作 [dst,na] = [numa,na]<<shl,dst的低shl位填充0
定义 shl.c:26

引用了 lmmp_add_(), lmmp_add_n_(), lmmp_add_n_sub_n_(), lmmp_cmp_(), lmmp_debug_assert, lmmp_param_assert, lmmp_shl_(), lmmp_toom_eval_dgr3_pm2_(), n, tp , 以及 xp.

被这些函数引用 lmmp_mul_toom43_(), lmmp_mul_toom44_(), lmmp_sqr_toom4_() , 以及 lmmp_toom_eval_dgr3_pm2_().

函数调用图:
这是这个函数的调用关系图:

◆ lmmp_toom_eval_pm1_()

int lmmp_toom_eval_pm1_ ( mp_ptr xp1,
mp_ptr xm1,
unsigned k,
mp_srcptr xp,
mp_size_t n,
mp_size_t hn,
mp_ptr tp )

通用高阶 Toom 求值:k次多项式在 x = +1 和 x = -1 处求值

参数
xp1输出:P(+1) 的结果(n+1 limbs)
xm1输出:P(-1) 的结果(n+1 limbs)
k输入:多项式次数(也是完整段的数量)
xp输入:多项式系数数组
n输入:每段完整系数的 limb 长度
hn输入:最后一段系数的实际长度
tp临时缓存空间(n+1 limbs)
警告
0<hn<=n, 3<k, xp1!=NULL, xm1!=NULL, xp!=NULL, tp!=NULL
返回
符号位:0=正,~0=负

在文件 mul_toom_eval.c 第 79 行定义.

79 {
80 unsigned i;
81 int neg;
82 lmmp_param_assert(k >= 4);
83
84 lmmp_param_assert(hn > 0);
85 lmmp_param_assert(hn <= n);
86
87 /* The degree k is also the number of full-size coefficients, so
88 * that last coefficient, of size hn, starts at xp + k*n. */
89
90 xp1[n] = lmmp_add_n_(xp1, xp, xp + 2 * n, n);
91 for (i = 4; i < k; i += 2) lmmp_add_(xp1, xp1, n + 1, xp + i * n, n);
92
93 tp[n] = lmmp_add_n_(tp, xp + n, xp + 3 * n, n);
94 for (i = 5; i < k; i += 2) lmmp_add_(tp, tp, n + 1, xp + i * n, n);
95
96 if (k & 1)
97 lmmp_add_(tp, tp, n + 1, xp + k * n, hn);
98 else
99 lmmp_add_(xp1, xp1, n + 1, xp + k * n, hn);
100
101 neg = (lmmp_cmp_(xp1, tp, n + 1) < 0) ? ~0 : 0;
102
103 if (neg)
104 lmmp_add_n_sub_n_(xp1, xm1, tp, xp1, n + 1);
105 else
106 lmmp_add_n_sub_n_(xp1, xm1, xp1, tp, n + 1);
107
108 lmmp_debug_assert(xp1[n] <= k);
109 lmmp_debug_assert(xm1[n] <= k / 2 + 1);
110
111 return neg;
112}
#define k

引用了 k, lmmp_add_(), lmmp_add_n_(), lmmp_add_n_sub_n_(), lmmp_cmp_(), lmmp_debug_assert, lmmp_param_assert, lmmp_toom_eval_pm1_(), n, tp , 以及 xp.

被这些函数引用 lmmp_mul_toom52_(), lmmp_mul_toom53_(), lmmp_mul_toom62_(), lmmp_mul_toom62_cache_(), lmmp_mul_toom62_cache_init_(), lmmp_mul_toom6h_(), lmmp_mul_toom8h_(), lmmp_sqr_toom6_(), lmmp_sqr_toom8_() , 以及 lmmp_toom_eval_pm1_().

函数调用图:
这是这个函数的调用关系图:

◆ lmmp_toom_eval_pm2_()

int lmmp_toom_eval_pm2_ ( mp_ptr xp2,
mp_ptr xm2,
unsigned k,
mp_srcptr xp,
mp_size_t n,
mp_size_t hn,
mp_ptr tp )

通用高阶 Toom 求值:k次多项式在 x = +2 和 x = -2 处求值

参数
xp2输出:P(+2) 的结果(n+1 limbs)
xm2输出:P(-2) 的结果(n+1 limbs)
k输入:多项式次数
xp输入:多项式系数数组
n输入:每段完整系数的 limb 长度
hn输入:最后一段系数的实际长度
tp临时缓存空间(n+1 limbs)
警告
0<hn<=n, 3 < k < LIMB_BITS, xp2!=NULL, xm2!=NULL, xp!=NULL, tp!=NULL
返回
符号位:0=正,~0=负

在文件 mul_toom_eval.c 第 126 行定义.

126 {
127 int i;
128 int neg;
129 mp_limb_t cy;
130 lmmp_param_assert(k >= 3);
132
133 lmmp_param_assert(hn > 0);
134 lmmp_param_assert(hn <= n);
135
136 /* The degree k is also the number of full-size coefficients, so
137 * that last coefficient, of size hn, starts at xp + k*n. */
138
139 cy = 0;
140 DO_addlsh2(xp2, xp + (k - 2) * n, xp + k * n, hn, cy);
141 if (hn != n)
142 cy = lmmp_add_1_(xp2 + hn, xp + (k - 2) * n + hn, n - hn, cy);
143 for (i = k - 4; i >= 0; i -= 2) DO_addlsh2(xp2, xp + i * n, xp2, n, cy);
144 xp2[n] = cy;
145
146 k--;
147
148 cy = 0;
149 DO_addlsh2(tp, xp + (k - 2) * n, xp + k * n, n, cy);
150 for (i = k - 4; i >= 0; i -= 2) DO_addlsh2(tp, xp + i * n, tp, n, cy);
151 tp[n] = cy;
152
153 if (k & 1)
154 lmmp_shl_(tp, tp, n + 1, 1);
155 else
156 lmmp_shl_(xp2, xp2, n + 1, 1);
157
158 neg = (lmmp_cmp_(xp2, tp, n + 1) < 0) ? ~0 : 0;
159
160 if (neg)
161 lmmp_add_n_sub_n_(xp2, xm2, tp, xp2, n + 1);
162 else
163 lmmp_add_n_sub_n_(xp2, xm2, xp2, tp, n + 1);
164
165 lmmp_debug_assert(xp2[n] < (1ull << (k + 2)) - 1);
166 lmmp_debug_assert(xm2[n] < ((1 << (k + 3)) - 1 - (1 ^ (k & 1))) / 3);
167
168 neg ^= ((k & 1) - 1);
169
170 return neg;
171}
#define LIMB_BITS
定义 lmmp.h:102
#define DO_addlsh2(d, a, b, n, cy)

引用了 DO_addlsh2, k, LIMB_BITS, lmmp_add_1_(), lmmp_add_n_sub_n_(), lmmp_cmp_(), lmmp_debug_assert, lmmp_param_assert, lmmp_shl_(), lmmp_toom_eval_pm2_(), n, tp , 以及 xp.

被这些函数引用 lmmp_mul_toom52_(), lmmp_mul_toom53_(), lmmp_mul_toom62_(), lmmp_mul_toom62_cache_(), lmmp_mul_toom62_cache_init_(), lmmp_mul_toom6h_(), lmmp_mul_toom8h_(), lmmp_sqr_toom6_(), lmmp_sqr_toom8_() , 以及 lmmp_toom_eval_pm2_().

函数调用图:
这是这个函数的调用关系图:

◆ lmmp_toom_eval_pm2exp_()

int lmmp_toom_eval_pm2exp_ ( mp_ptr xp2,
mp_ptr xm2,
unsigned k,
mp_srcptr xp,
mp_size_t n,
mp_size_t hn,
unsigned shift,
mp_ptr tp )

通用高阶 Toom 求值:k次多项式在 x = +2^shift 和 x = -2^shift 处求值 (toom6h 的 ±4 / toom8h 的 ±4、±8 点)

参数
xp2输出:P(+2^shift) 的结果(n+1 limbs)
xm2输出:P(-2^shift) 的结果(n+1 limbs);求值过程中亦作暂存
k输入:多项式次数(完整段数)
xp输入:多项式系数数组(k 个 n 长段 + 1 个 hn 长尾段)
n输入:每段完整系数的 limb 长度
hn输入:最后一段系数的实际长度
shift输入:2 的幂指数(1<=shift,且 k*shift < LIMB_BITS)
tp临时缓存空间(n+1 limbs)
警告
0<hn<=n, 3<=k, k*shift<LIMB_BITS, sep(xp2,[xp|tp]), sep(xm2,[xp|tp])
返回
符号位:0=正,~0=负(对应 P(-2^shift))

在文件 mul_toom_eval.c 第 175 行定义.

175 {
176 unsigned i;
177 int neg;
178 mp_limb_t cy;
179
180 lmmp_param_assert(k >= 3);
181 lmmp_param_assert(k * shift < LIMB_BITS);
182 lmmp_param_assert(hn > 0);
183 lmmp_param_assert(hn <= n);
184
185 /* k 次多项式(k 个完整段 + hn 长尾段)在 x = ±2^shift 处求值:
186 * 偶下标系数和进 xp2(k 偶时含尾段),奇下标进 tp(k 奇时含尾段),
187 * 点值和/差经 add_n_sub_n 一次分离,返回差半边的符号。 */
188
189 lmmp_copy(xp2, xp, n);
190 xp2[n] = 0;
191 for (i = 2; i < k; i += 2)
192 xp2[n] += lmmp_addmul_1_(xp2, xp + i * n, n, (mp_limb_t)1 << (i * shift));
193 if ((k & 1) == 0) {
194 cy = lmmp_addmul_1_(xp2, xp + k * n, hn, (mp_limb_t)1 << (k * shift));
195 lmmp_inc_1(xp2 + hn, cy);
196 }
197
198 tp[n] = lmmp_shl_(tp, xp + n, n, shift);
199 for (i = 3; i < k; i += 2)
200 tp[n] += lmmp_addmul_1_(tp, xp + i * n, n, (mp_limb_t)1 << (i * shift));
201 if (k & 1) {
202 cy = lmmp_addmul_1_(tp, xp + k * n, hn, (mp_limb_t)1 << (k * shift));
203 lmmp_inc_1(tp + hn, cy);
204 }
205
206 neg = (lmmp_cmp_(xp2, tp, n + 1) < 0) ? ~0 : 0;
207
208 if (neg)
209 lmmp_add_n_sub_n_(xp2, xm2, tp, xp2, n + 1);
210 else
211 lmmp_add_n_sub_n_(xp2, xm2, xp2, tp, n + 1);
212
213 return neg;
214}
#define lmmp_copy(dst, src, n)
定义 lmmp.h:474
mp_limb_t lmmp_addmul_1_(mp_ptr numa, mp_srcptr numb, mp_size_t n, mp_limb_t b)
乘以单limb并累加操作 [numa,n] += [numb,n] * b
定义 mul_1.c:76
#define lmmp_inc_1(p, inc)
加指定值宏(预期无进位)

引用了 k, LIMB_BITS, lmmp_add_n_sub_n_(), lmmp_addmul_1_(), lmmp_cmp_(), lmmp_copy, lmmp_inc_1, lmmp_param_assert, lmmp_shl_(), lmmp_toom_eval_pm2exp_(), n, tp , 以及 xp.

被这些函数引用 lmmp_mul_toom6h_(), lmmp_mul_toom8h_(), lmmp_sqr_toom6_(), lmmp_sqr_toom8_() , 以及 lmmp_toom_eval_pm2exp_().

函数调用图:
这是这个函数的调用关系图:

◆ lmmp_toom_eval_pm2rexp_()

int lmmp_toom_eval_pm2rexp_ ( mp_ptr rp,
mp_ptr rm,
unsigned q,
mp_srcptr ap,
mp_size_t n,
mp_size_t t,
unsigned s,
mp_ptr ws )

通用高阶 Toom 求值:q次多项式在 x = +1/2^s 和 x = -1/2^s 处求值, 结果放大 2^(s*q)(toom6h 的 ±1/2、±1/4 / toom8h 的 ±1/2、±1/4、±1/8 点)

参数
rp输出:2^(s*q)*P(+1/2^s) 的结果(n+1 limbs)
rm输出:2^(s*q)*P(-1/2^s) 的结果(n+1 limbs)
q输入:多项式次数(完整段数)
ap输入:多项式系数数组(q 个 n 长段 + 1 个 t 长尾段)
n输入:每段完整系数的 limb 长度
t输入:最后一段系数的实际长度
s输入:2 的幂指数(s!=0,且 q*s < LIMB_BITS)
ws临时缓存空间(n+1 limbs)
警告
0<t<=n, 1<q, sep(rp,[ap|ws]), sep(rm,[ap|ws])
返回
符号位:0=正,~0=负(对应 P(-1/2^s))

在文件 mul_toom_eval.c 第 216 行定义.

216 {
217 unsigned i;
218 int neg;
219 mp_limb_t cy;
220
222 lmmp_param_assert(t > 0);
223 lmmp_param_assert(s != 0); /* s==0 时应改用 eval_pm1 */
224 lmmp_param_assert(q > 1);
226
227 /* q 次多项式(q 个完整段 + t 长尾段)在 x = ±1/2^s 处求值,结果放大
228 * 2^(s*q):第 i 段权重 2^(s*(q-i)),即倒序多项式在 2^s 处的点值。
229 * 偶下标和进 rp(q 偶时含尾段),奇下标进 ws(q 奇时含尾段)。 */
230
231 rp[n] = lmmp_shl_(rp, ap, n, s * q);
232 ws[n] = lmmp_shl_(ws, ap + n, n, s * (q - 1));
233 if (q & 1) {
234 cy = lmmp_add_(ws, ws, n + 1, ap + n * q, t);
235 lmmp_debug_assert(cy == 0);
236 rp[n] += lmmp_addmul_1_(rp, ap + n * (q - 1), n, (mp_limb_t)1 << s);
237 } else {
238 cy = lmmp_add_(rp, rp, n + 1, ap + n * q, t);
239 lmmp_debug_assert(cy == 0);
240 }
241 for (i = 2; i + 1 < q; i += 2) {
242 rp[n] += lmmp_addmul_1_(rp, ap + n * i, n, (mp_limb_t)1 << (s * (q - i)));
243 ws[n] += lmmp_addmul_1_(ws, ap + n * (i + 1), n, (mp_limb_t)1 << (s * (q - i - 1)));
244 }
245
246 neg = (lmmp_cmp_(rp, ws, n + 1) < 0) ? ~0 : 0;
247
248 if (neg)
249 lmmp_add_n_sub_n_(rp, rm, ws, rp, n + 1);
250 else
251 lmmp_add_n_sub_n_(rp, rm, rp, ws, n + 1);
252
253 return neg;
254}
#define rp
#define t
#define s

引用了 LIMB_BITS, lmmp_add_(), lmmp_add_n_sub_n_(), lmmp_addmul_1_(), lmmp_cmp_(), lmmp_debug_assert, lmmp_param_assert, lmmp_shl_(), lmmp_toom_eval_pm2rexp_(), n, rp, s , 以及 t.

被这些函数引用 lmmp_mul_toom6h_(), lmmp_mul_toom8h_(), lmmp_sqr_toom6_(), lmmp_sqr_toom8_() , 以及 lmmp_toom_eval_pm2rexp_().

函数调用图:
这是这个函数的调用关系图:

◆ lmmp_toom_interp12_()

void lmmp_toom_interp12_ ( mp_ptr dst,
mp_ptr r1,
mp_ptr r3,
mp_ptr r5,
mp_size_t n,
mp_size_t spt,
int half,
mp_ptr tp )

Toom插值计算(12点插值):用于 Toom-6.5(toom6h/toom6 平方)乘法 评估点:inf(仅 half), ±4, ±2, ±1, ±1/2, ±1/4, 0

参数
dst结果缓冲区(half ? 11n+spt : 10n+spt limbs) r8=f(0) 在 [dst,2n],r6 在 [dst+3n,3n+1], r4 在 [dst+7n,3n+1],r0 在 [dst+11n,spt]
r1输入/临时:±8...±4 点对混合后的奇系数(3n+1 limbs)
r3输入/临时:±1 点对(3n+1 limbs)
r5输入/临时:±1/2 点对(3n+1 limbs)
n每段标准 limb 长度
spt顶部系数 r0 的长度(0<spt<=2n)
half非零表示乘积多项式次数为奇(需要 inf 点,r0 有效)
tp临时缓存(3n+1 limbs)
注解
r1=f(±4), r2=f(±2), r3=f(±1), r4=f(±1/4), r5=f(±1/2); 各 ± 点对须先经 lmmp_toom_couple_handling_ 混合;负中间值以 补码存放,输入被破坏
警告
n>0, 0<spt<=2n, sep(tp,[dst|r1|r3|r5])

在文件 mul_toom_interp12.c 第 40 行定义.

42 {
43 mp_limb_t cy, cy2;
44 mp_size_t n3, n3p1;
45 n3 = 3 * n;
46 n3p1 = n3 + 1;
47
49 lmmp_param_assert(spt > 0);
50 lmmp_param_assert(spt <= 2 * n);
51
52#define r4 (dst + n3) /* 3n+1 */
53#define r2 (dst + 7 * n) /* 3n+1 */
54#define r0 (dst + 11 * n) /* spt <= 2n */
55
56 /* 插值序列(值引用为混合后的和/差半边):
57 r? <- (r? - r0*x)/d 的消顶部项 + 交叉消元 + 精确除,最后重组 */
58
59 if (half != 0) {
60 cy = lmmp_sub_n_(r3, r3, r0, spt);
61 lmmp_dec_1(r3 + spt, cy);
62
63 cy = lmmp_submul_1_(r2, r0, spt, (mp_limb_t)1 << 10);
64 lmmp_dec_1(r2 + spt, cy);
65 DO_subrsh(r5, n3p1, r0, spt, 2);
66
67 cy = lmmp_submul_1_(r1, r0, spt, (mp_limb_t)1 << 20);
68 lmmp_dec_1(r1 + spt, cy);
69 DO_subrsh(r4, n3p1, r0, spt, 4);
70 }
71
72 r4[n3] -= lmmp_submul_1_(r4 + n, dst, 2 * n, (mp_limb_t)1 << 20);
73 DO_subrsh(r1 + n, 2 * n + 1, dst, 2 * n, 4);
74
75 lmmp_add_n_sub_n_(r1, r4, r4, r1, n3p1);
76
77 r5[n3] -= lmmp_submul_1_(r5 + n, dst, 2 * n, (mp_limb_t)1 << 10);
78 DO_subrsh(r2 + n, 2 * n + 1, dst, 2 * n, 2);
79
80 lmmp_add_n_sub_n_(r2, r5, r5, r2, n3p1);
81
82 r3[n3] -= lmmp_sub_n_(r3 + n, r3 + n, dst, 2 * n);
83
84 lmmp_submul_1_(r4, r5, n3p1, 257);
85 /* 随后除以 2835*4,操作数可能为负(补码) */
86 lmmp_divexact_odd_pi_(r4, r4, n3p1, 2835, BINVERT_2835_, 2);
87 if ((r4[n3] & (LIMB_MAX << (LIMB_BITS - 3))) != 0)
88 r4[n3] |= LIMB_MAX << (LIMB_BITS - 2);
89
90 lmmp_addmul_1_(r5, r4, n3p1, 60);
91 lmmp_divexact_odd_pi_(r5, r5, n3p1, 255, BINVERT_255_, 0);
92
93 cy = lmmp_submul_1_(r2, r3, n3p1, (mp_limb_t)1 << 5);
94 lmmp_debug_assert(cy == 0);
95
96 cy = lmmp_submul_1_(r1, r2, n3p1, 100);
97 lmmp_debug_assert(cy == 0);
98 cy = lmmp_submul_1_(r1, r3, n3p1, (mp_limb_t)1 << 9);
99 lmmp_debug_assert(cy == 0);
100 lmmp_divexact_odd_pi_(r1, r1, n3p1, 42525, BINVERT_42525_, 0);
101
102 cy = lmmp_submul_1_(r2, r1, n3p1, 225);
103 lmmp_debug_assert(cy == 0);
104 lmmp_divexact_odd_pi_(r2, r2, n3p1, 9, BINVERT_9_, 2);
105
106 cy = lmmp_sub_n_(r3, r3, r2, n3p1);
107 lmmp_debug_assert(cy == 0);
108
109 lmmp_shr1sub_n_(r4, r2, r4, n3p1);
110 r4[n3p1 - 1] &= LIMB_MAX >> 1;
111 cy = lmmp_sub_n_(r2, r2, r4, n3p1);
112 lmmp_debug_assert(cy == 0);
113
114 lmmp_shr1add_n_(r5, r5, r1, n3p1);
115 r5[n3p1 - 1] &= LIMB_MAX >> 1;
116
117 /* 最后两步插值(可并入重组) */
118 cy = lmmp_sub_n_(r3, r3, r1, n3p1);
119 lmmp_debug_assert(cy == 0);
120 cy = lmmp_sub_n_(r1, r1, r5, n3p1);
121 lmmp_debug_assert(cy == 0);
122
123 (void)tp; /* 现有原语集(submul/addmul/原生 add_n_sub_n)不消耗临时区 */
124
125 /***************************** 重组 *******************************/
126 /*
127 dst 操作前:
128 |M r0|L r0|___||H r2|M r2|L r2|___||H r4|M r4|L r4|____|H r8|L r8|dst
129 求和方案:
130 |__12|n_11|n_10|n__9|n__8|n__7|n__6|n__5|n__4|n__3|n__2|n___|n___|dst
131 |M r0|L r0|___||H r2|M r2|L r2|___||H r4|M r4|L r4|____|H_r8|L_r8|dst
132 ||H r1|M r1|L r1| ||H r3|M r3|L r3| ||H_r5|M_r5|L_r5|
133 */
134
135 cy = lmmp_add_n_(dst + n, dst + n, r5, n);
136 cy = lmmp_add_1_(dst + 2 * n, r5 + n, n, cy);
137 cy = r5[n3] + lmmp_add_nc_(dst + n3, dst + n3, r5 + 2 * n, n, cy);
138 lmmp_inc_1(dst + n3 + n, cy);
139
140 dst[2 * n3] += lmmp_add_n_(dst + 5 * n, dst + 5 * n, r3, n);
141 cy = lmmp_add_1_(dst + 2 * n3, r3 + n, n, dst[2 * n3]);
142 cy = r3[n3] + lmmp_add_nc_(dst + 7 * n, dst + 7 * n, r3 + 2 * n, n, cy);
143 lmmp_inc_1(dst + 8 * n, cy);
144
145 dst[10 * n] += lmmp_add_n_(dst + 9 * n, dst + 9 * n, r1, n);
146 if (half) {
147 cy = lmmp_add_1_(dst + 10 * n, r1 + n, n, dst[10 * n]);
148 if (spt > n) {
149 cy = r1[n3] + lmmp_add_nc_(dst + 11 * n, dst + 11 * n, r1 + 2 * n, n, cy);
150 lmmp_inc_1(dst + 4 * n3, cy);
151 } else {
152 cy2 = lmmp_add_nc_(dst + 11 * n, dst + 11 * n, r1 + 2 * n, spt, cy);
153 lmmp_debug_assert(cy2 == 0);
154 }
155 } else {
156 cy = lmmp_add_1_(dst + 10 * n, r1 + n, spt, dst[10 * n]);
157 lmmp_debug_assert(cy == 0);
158 }
159
160#undef r4
161#undef r2
162#undef r0
163}
mp_limb_t lmmp_divexact_odd_pi_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_limb_t d, mp_limb_t di, unsigned shr)
通用奇除数精确除,可带 2^shr 因子: [dst,na] = [numa,na] / (d*2^shr),其中 d 为奇数、di = d^(-1) mod B
uint64_t mp_size_t
定义 lmmp.h:93
#define LIMB_MAX
定义 lmmp.h:105
mp_limb_t lmmp_add_nc_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n, mp_limb_t c)
带进位的n位加法 [dst,n] = [numa,n] + [numb,n] + c
定义 add_n.c:58
#define lmmp_dec_1(p, dec)
减指定值宏(预期无借位)
mp_limb_t lmmp_submul_1_(mp_ptr numa, mp_srcptr numb, mp_size_t n, mp_limb_t b)
乘以单limb并累减操作 [numa,n] -= [numb,n] * b
#define r2
#define r1
#define r3
#define r0
#define r4
#define r5
#define BINVERT_42525_
#define DO_subrsh(dst, nd, src, ns, s)
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define BINVERT_9_
#define BINVERT_255_
#define BINVERT_2835_

引用了 BINVERT_255_, BINVERT_2835_, BINVERT_42525_, BINVERT_9_, DO_subrsh, LIMB_BITS, LIMB_MAX, lmmp_add_1_(), lmmp_add_n_(), lmmp_add_n_sub_n_(), lmmp_add_nc_(), lmmp_addmul_1_(), lmmp_debug_assert, lmmp_dec_1, lmmp_divexact_odd_pi_(), lmmp_inc_1, lmmp_param_assert, lmmp_shr1add_n_(), lmmp_shr1sub_n_(), lmmp_sub_n_(), lmmp_submul_1_(), lmmp_toom_interp12_(), n, r0, r1, r2, r3, r4, r5 , 以及 tp.

被这些函数引用 lmmp_mul_toom6h_(), lmmp_sqr_toom6_() , 以及 lmmp_toom_interp12_().

函数调用图:
这是这个函数的调用关系图:

◆ lmmp_toom_interp16_()

void lmmp_toom_interp16_ ( mp_ptr dst,
mp_ptr r1,
mp_ptr r3,
mp_ptr r5,
mp_ptr r7,
mp_size_t n,
mp_size_t spt,
int half,
mp_ptr tp )

Toom插值计算(16点插值):用于 Toom-8.5(toom8h/toom8 平方)乘法 评估点:inf(仅 half), ±8, ±4, ±2, ±1, ±1/2, ±1/4, ±1/8, 0

参数
dst结果缓冲区(half ? 15n+spt : 14n+spt limbs) r8=f(0) 在 [dst,2n],r6 在 [dst+3n,3n+1],r4 在 [dst+7n,3n+1], r2 在 [dst+11n,3n+1],r0 在 [dst+15n,spt]
r1输入/临时:±8 点对混合后的奇系数(3n+1 limbs)
r3输入/临时:±2 点对(3n+1 limbs)
r5输入/临时:±1/4 点对(3n+1 limbs)
r7输入/临时:±1/8 点对(3n+1 limbs)
n每段标准 limb 长度
spt顶部系数 r0 的长度(0<spt<=2n)
half非零表示乘积多项式次数为奇(需要 inf 点,r0 有效)
tp临时缓存(3n+1 limbs)
注解
r1=f(±8), r2=f(±4), r3=f(±2), r4=f(±1), r5=f(±1/4), r6=f(±1/2), r7=f(±1/8);各 ± 点对须先经 lmmp_toom_couple_handling_ 混合; 负中间值以补码存放,输入被破坏
警告
n>0, 0<spt<=2n, sep(tp,[dst|r1|r3|r5|r7])

在文件 mul_toom_interp16.c 第 42 行定义.

44 {
45 mp_limb_t cy, cy2;
46 mp_size_t n3, n3p1;
47 n3 = 3 * n;
48 n3p1 = n3 + 1;
49
51 lmmp_param_assert(spt > 0);
52 lmmp_param_assert(spt <= 2 * n);
53
54#define r6 (dst + n3) /* 3n+1 */
55#define r4 (dst + 7 * n) /* 3n+1 */
56#define r2 (dst + 11 * n) /* 3n+1 */
57#define r0 (dst + 15 * n) /* spt <= 2n */
58
59 if (half != 0) {
60 cy = lmmp_sub_n_(r4, r4, r0, spt);
61 lmmp_dec_1(r4 + spt, cy);
62
63 cy = lmmp_submul_1_(r3, r0, spt, (mp_limb_t)1 << 14);
64 lmmp_dec_1(r3 + spt, cy);
65 DO_subrsh(r6, n3p1, r0, spt, 2);
66
67 cy = lmmp_submul_1_(r2, r0, spt, (mp_limb_t)1 << 28);
68 lmmp_dec_1(r2 + spt, cy);
69 DO_subrsh(r5, n3p1, r0, spt, 4);
70
71 cy = lmmp_submul_1_(r1, r0, spt, (mp_limb_t)1 << 42);
72 lmmp_dec_1(r1 + spt, cy);
73 DO_subrsh(r7, n3p1, r0, spt, 6);
74 }
75
76 r5[n3] -= lmmp_submul_1_(r5 + n, dst, 2 * n, (mp_limb_t)1 << 28);
77 DO_subrsh(r2 + n, 2 * n + 1, dst, 2 * n, 4);
78
79 lmmp_add_n_sub_n_(r2, r5, r5, r2, n3p1);
80
81 r6[n3] -= lmmp_submul_1_(r6 + n, dst, 2 * n, (mp_limb_t)1 << 14);
82 DO_subrsh(r3 + n, 2 * n + 1, dst, 2 * n, 2);
83
84 lmmp_add_n_sub_n_(r3, r6, r6, r3, n3p1);
85
86 r7[n3] -= lmmp_submul_1_(r7 + n, dst, 2 * n, (mp_limb_t)1 << 42);
87 DO_subrsh(r1 + n, 2 * n + 1, dst, 2 * n, 6);
88
89 lmmp_add_n_sub_n_(r1, r7, r7, r1, n3p1);
90
91 r4[n3] -= lmmp_sub_n_(r4 + n, r4 + n, dst, 2 * n);
92
93 lmmp_submul_1_(r5, r6, n3p1, 1028);
94 lmmp_submul_1_(r7, r5, n3p1, 1300);
95 lmmp_submul_1_(r7, r6, n3p1, 1052688);
96 lmmp_divexact_odd_pi_(r7, r7, n3p1, (mp_limb_t)255 * 188513325, BINVERT_255x188513325_, 0);
97
98 lmmp_submul_1_(r5, r7, n3p1, 12567555);
99 /* 随后除以 2835*64,操作数可能为负(补码) */
100 lmmp_divexact_odd_pi_(r5, r5, n3p1, 2835, BINVERT_2835_, 6);
101 if ((r5[n3] & (LIMB_MAX << (LIMB_BITS - 7))) != 0)
102 r5[n3] |= LIMB_MAX << (LIMB_BITS - 6);
103
104 lmmp_submul_1_(r6, r7, n3p1, 4095);
105 lmmp_addmul_1_(r6, r5, n3p1, 240);
106 /* 随后除以 255*4,操作数可能为负(补码) */
107 lmmp_divexact_odd_pi_(r6, r6, n3p1, 255, BINVERT_255_, 2);
108 if ((r6[n3] & (LIMB_MAX << (LIMB_BITS - 3))) != 0)
109 r6[n3] |= LIMB_MAX << (LIMB_BITS - 2);
110
111 cy = lmmp_submul_1_(r3, r4, n3p1, (mp_limb_t)1 << 7);
112 lmmp_debug_assert(cy == 0);
113
114 cy = lmmp_submul_1_(r2, r4, n3p1, (mp_limb_t)1 << 13);
115 lmmp_debug_assert(cy == 0);
116 cy = lmmp_submul_1_(r2, r3, n3p1, 400);
117 lmmp_debug_assert(cy == 0);
118
119 lmmp_submul_1_(r1, r4, n3p1, (mp_limb_t)1 << 19);
120 lmmp_submul_1_(r1, r2, n3p1, 1428);
121 lmmp_submul_1_(r1, r3, n3p1, 112896);
122 lmmp_divexact_odd_pi_(r1, r1, n3p1, (mp_limb_t)255 * 182712915, BINVERT_255x182712915_, 0);
123
124 cy = lmmp_submul_1_(r2, r1, n3p1, 15181425);
125 lmmp_debug_assert(cy == 0);
126 lmmp_divexact_odd_pi_(r2, r2, n3p1, 42525, BINVERT_42525_, 4);
127
128 cy = lmmp_submul_1_(r3, r1, n3p1, 3969);
129 lmmp_debug_assert(cy == 0);
130 cy = lmmp_submul_1_(r3, r2, n3p1, 900);
131 lmmp_debug_assert(cy == 0);
132 lmmp_divexact_odd_pi_(r3, r3, n3p1, 9, BINVERT_9_, 4);
133
134 cy = lmmp_sub_n_(r4, r4, r1, n3p1);
135 lmmp_debug_assert(cy == 0);
136 cy = lmmp_sub_n_(r4, r4, r3, n3p1);
137 lmmp_debug_assert(cy == 0);
138 cy = lmmp_sub_n_(r4, r4, r2, n3p1);
139 lmmp_debug_assert(cy == 0);
140
141 lmmp_shr1add_n_(r6, r2, r6, n3p1);
142 r6[n3p1 - 1] &= LIMB_MAX >> 1;
143 cy = lmmp_sub_n_(r2, r2, r6, n3p1);
144 lmmp_debug_assert(cy == 0);
145
146 lmmp_shr1sub_n_(r5, r3, r5, n3p1);
147 r5[n3p1 - 1] &= LIMB_MAX >> 1;
148 cy = lmmp_sub_n_(r3, r3, r5, n3p1);
149 lmmp_debug_assert(cy == 0);
150
151 lmmp_shr1add_n_(r7, r1, r7, n3p1);
152 r7[n3p1 - 1] &= LIMB_MAX >> 1;
153 cy = lmmp_sub_n_(r1, r1, r7, n3p1);
154 lmmp_debug_assert(cy == 0);
155
156 (void)tp; /* 现有原语集(submul/addmul/原生 add_n_sub_n)不消耗临时区 */
157
158 /***************************** 重组 *******************************/
159 /*
160 dst 操作前:
161 |M r0|L r0|___||H r2|M r2|L r2|___||H r4|M r4|L r4|___||H r6|M r6|L r6|____|H_r8|L_r8|dst
162 求和方案:
163 |__16|n_15|n_14|n_13|n_12|n_11|n_10|n__9|n__8|n__7|n__6|n__5|n__4|n__3|n__2|n___|n___|dst
164 |M r0|L r0|___||H r2|M r2|L r2|___||H r4|M r4|L r4|___||H r6|M r6|L r6|____|H_r8|L_r8|dst
165 ||H r1|M r1|L r1| ||H r3|M r3|L r3| ||H_r5|M_r5|L_r5| ||H_r7|M_r7|L_r7|
166 */
167
168 cy = lmmp_add_n_(dst + n, dst + n, r7, n);
169 cy = lmmp_add_1_(dst + 2 * n, r7 + n, n, cy);
170 cy = r7[n3] + lmmp_add_nc_(dst + n3, dst + n3, r7 + 2 * n, n, cy);
171 lmmp_inc_1(dst + 4 * n, cy);
172
173 dst[2 * n3] += lmmp_add_n_(dst + 5 * n, dst + 5 * n, r5, n);
174 cy = lmmp_add_1_(dst + 2 * n3, r5 + n, n, dst[2 * n3]);
175 cy = r5[n3] + lmmp_add_nc_(dst + 7 * n, dst + 7 * n, r5 + 2 * n, n, cy);
176 lmmp_inc_1(dst + 8 * n, cy);
177
178 dst[10 * n] += lmmp_add_n_(dst + 9 * n, dst + 9 * n, r3, n);
179 cy = lmmp_add_1_(dst + 10 * n, r3 + n, n, dst[10 * n]);
180 cy = r3[n3] + lmmp_add_nc_(dst + 11 * n, dst + 11 * n, r3 + 2 * n, n, cy);
181 lmmp_inc_1(dst + 12 * n, cy);
182
183 dst[14 * n] += lmmp_add_n_(dst + 13 * n, dst + 13 * n, r1, n);
184 if (half) {
185 cy = lmmp_add_1_(dst + 14 * n, r1 + n, n, dst[14 * n]);
186 if (spt > n) {
187 cy = r1[n3] + lmmp_add_nc_(dst + 15 * n, dst + 15 * n, r1 + 2 * n, n, cy);
188 lmmp_inc_1(dst + 16 * n, cy);
189 } else {
190 cy2 = lmmp_add_nc_(dst + 15 * n, dst + 15 * n, r1 + 2 * n, spt, cy);
191 lmmp_debug_assert(cy2 == 0);
192 }
193 } else {
194 cy = lmmp_add_1_(dst + 14 * n, r1 + n, spt, dst[14 * n]);
195 lmmp_debug_assert(cy == 0);
196 }
197
198#undef r6
199#undef r4
200#undef r2
201#undef r0
202}
#define r6
#define r7
#define BINVERT_255x182712915_
#define BINVERT_255x188513325_

引用了 BINVERT_255_, BINVERT_255x182712915_, BINVERT_255x188513325_, BINVERT_2835_, BINVERT_42525_, BINVERT_9_, DO_subrsh, LIMB_BITS, LIMB_MAX, lmmp_add_1_(), lmmp_add_n_(), lmmp_add_n_sub_n_(), lmmp_add_nc_(), lmmp_addmul_1_(), lmmp_debug_assert, lmmp_dec_1, lmmp_divexact_odd_pi_(), lmmp_inc_1, lmmp_param_assert, lmmp_shr1add_n_(), lmmp_shr1sub_n_(), lmmp_sub_n_(), lmmp_submul_1_(), lmmp_toom_interp16_(), n, r0, r1, r2, r3, r4, r5, r6, r7 , 以及 tp.

被这些函数引用 lmmp_mul_toom8h_(), lmmp_sqr_toom8_() , 以及 lmmp_toom_interp16_().

函数调用图:
这是这个函数的调用关系图:

◆ lmmp_toom_interp5_()

void lmmp_toom_interp5_ ( mp_ptr dst,
mp_ptr v2,
mp_ptr vm1,
mp_size_t n,
mp_size_t spt,
int vm1_neg,
mp_limb_t vinf0 )

Toom插值计算(5点插值),用于Toom-33和Toom-42乘法算法

Copyright (C) 2026 HJimmyK (Jericho Knox)

参数
dst输出结果缓冲区,存储插值计算结果 v(0)储存在[dst,2n],v(1)储存在[dst+2n,2n]
v2v(2)插值点值,长度为 2n+1 个limb
vm1v(-1)插值点值,长度为 2n+1 个limb
n操作数的 limb 长度
spt系数r4的长度
vm1_neg符号标记:v(-1)是否为负数(1表示负,0表示正)
vinf0无穷远点插值的低64位值
警告
dst!=NULL, v2!=NULL, vm1!=NULL, n>0

Toom插值计算(5点插值),用于Toom-33和Toom-42乘法算法

This file is part of LMMP.

LMMP is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library. If not, see https://www.gnu.org/licenses/.

SPDX-License-Identifier: LGPL-3.0-or-later

在文件 mul_toom_interp5.c 第 27 行定义.

27 {
28 mp_limb_t cy, saved;
29 mp_size_t dnp = 2 * n + 1;
30
31#define r0 (dst)
32#define r1 (dst + n)
33#define r2 (dst + 2 * n)
34#define r3 (dst + 3 * n)
35#define r4 (dst + 4 * n)
36#define v0 r0
37#define v1 r2
38#define vinf r4
39
40 // v2=(v2-vm1)/3
41 if (vm1_neg)
42 lmmp_add_n_(v2, v2, vm1, dnp);
43 else
44 lmmp_sub_n_(v2, v2, vm1, dnp);
46
47 // vm1=(v1-vm1)/2
48 if (vm1_neg)
49 lmmp_shr1add_n_(vm1, v1, vm1, dnp);
50 else
51 lmmp_shr1sub_n_(vm1, v1, vm1, dnp);
52
53 // v1=v1-v0
54 v1[2 * n] -= lmmp_sub_n_(v1, v1, v0, 2 * n);
55
56 // v2=(v2-v1)/2
57 lmmp_shr1sub_n_(v2, v2, v1, dnp);
58
59 // v1=v1-vm1
60 lmmp_sub_n_(v1, v1, vm1, dnp);
61
62 // add vm1 at correct place.
63 cy = lmmp_add_n_(r1, r1, vm1, dnp);
64 lmmp_inc_1(r3 + 1, cy); // at most propagate to v1[2*n]
65
66 saved = v1[2 * n]; // it is vinf[0]
67 vinf[0] = vinf0; // correct value of vinf
68
69 // v2=v2-vinf*2
70 cy = lmmp_shl_(vm1, vinf, spt, 1);
71 cy += lmmp_sub_n_(v2, v2, vm1, spt);
72 lmmp_dec_1(v2 + spt, cy);
73
74 // vinf+=v2h, no overflow
75 cy = lmmp_add_n_(vinf, vinf, v2 + n, n + 1);
76 lmmp_inc_1(r3 + dnp, cy);
77
78 // v1-=vinf, (same time vmh-=v2h)
79 cy = lmmp_sub_n_(v1, v1, vinf, spt);
80 vinf0 = vinf[0];
81 v1[2 * n] = saved; // correct value of v1
82 lmmp_dec_1(v1 + spt, cy);
83
84 // vml-=v2l
85 cy = lmmp_sub_n_(r1, r1, v2, n);
86 lmmp_dec_1(v1, cy);
87
88 // last v2l
89 cy = lmmp_add_n_(r3, r3, v2, n);
90 v1[2 * n] += cy; // no carry
91 lmmp_inc_1(vinf, vinf0);
92}
void lmmp_divexact_by3_(mp_ptr dst, mp_srcptr numa, mp_size_t na)
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define v0
#define vinf
#define vm1
#define v1
#define v2

引用了 lmmp_add_n_(), lmmp_dec_1, lmmp_divexact_by3_(), lmmp_inc_1, lmmp_shl_(), lmmp_shr1add_n_(), lmmp_shr1sub_n_(), lmmp_sub_n_(), lmmp_toom_interp5_(), n, r1, r3, v0, v1, v2, vinf , 以及 vm1.

被这些函数引用 lmmp_mul_toom33_(), lmmp_mul_toom42_(), lmmp_mul_toom42_cache_(), lmmp_mul_toom42_cache_init_(), lmmp_sqr_toom3_() , 以及 lmmp_toom_interp5_().

函数调用图:
这是这个函数的调用关系图:

◆ lmmp_toom_interp6_()

void lmmp_toom_interp6_ ( mp_ptr dst,
mp_size_t n,
enum toom6_flags flags,
mp_ptr w4,
mp_ptr w2,
mp_ptr w1,
mp_size_t w0n )

Toom插值计算(6点插值):用于Toom-43和Toom-52 乘法算法

Copyright (C) 2026 HJimmyK (Jericho Knox)

参数
dst最终乘积结果缓冲区(5n + w0n limbs) w5 储存在[dst,2n], w3 储存在[dst+2n,2n+1], w0 储存在[dst+5n,w0n].
nToom-6 拆分后每段标准 limb 长度
flags插值符号标志位
w4输入/临时:点值 W4 缓冲区(2n+1 limbs)
w2输入/临时:点值 W2 缓冲区(2n+1 limbs)
w1输入/临时:点值 W1 缓冲区(2n+1 limbs)
w0n输入:最低位段 W0 的实际 limb 长度(0 < w0n <= 2n)
注解
w5=f(0), w4=f(-1), w3=f(1), w2=f(-2), w1=f(2), w0=f(inf)
警告
n>0, 0<w0n<=2n, dst!=NULL, w4!=NULL, w2!=NULL, w1!=NULL

Toom插值计算(6点插值):用于Toom-43和Toom-52 乘法算法

This file is part of LMMP.

LMMP is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library. If not, see https://www.gnu.org/licenses/.

SPDX-License-Identifier: LGPL-3.0-or-later

在文件 mul_toom_interp6.c 第 56 行定义.

64 {
65
67 lmmp_param_assert(2 * n >= w0n && w0n > 0);
68 mp_limb_t cy;
69 /* cy6 can be stored in w1[2*n], cy4 in w4[0], embankment in w2[0] */
70 mp_limb_t cy4, cy6, embankment;
71
72#define w5 dst /* 2n */
73#define w3 (dst + 2 * n) /* 2n+1 */
74#define w0 (dst + 5 * n) /* w0n */
75
76 /* W2 =(W1 - W2)>>2 */
77 if (flags & toom6_vm2_neg)
78 lmmp_add_n_(w2, w1, w2, 2 * n + 1);
79 else
80 lmmp_sub_n_(w2, w1, w2, 2 * n + 1);
81 lmmp_shr_(w2, w2, 2 * n + 1, 2);
82
83 /* W1 =(W1 - W5)>>1 */
84 w1[2 * n] -= lmmp_sub_n_(w1, w1, w5, 2 * n);
85 lmmp_shr_(w1, w1, 2 * n + 1, 1);
86
87 /* W1 =(W1 - W2)>>1 */
88 lmmp_shr1sub_n_(w1, w1, w2, 2 * n + 1);
89
90 /* W4 =(W3 - W4)>>1 */
91 if (flags & toom6_vm1_neg) {
92 lmmp_shr1add_n_(w4, w3, w4, 2 * n + 1);
93 } else {
94 lmmp_shr1sub_n_(w4, w3, w4, 2 * n + 1);
95 }
96
97 /* W2 =(W2 - W4)/3 */
98 lmmp_sub_n_(w2, w2, w4, 2 * n + 1);
99 lmmp_divexact_by3_(w2, w2, 2 * n + 1);
100
101 /* W3 = W3 - W4 - W5 */
102 lmmp_sub_n_(w3, w3, w4, 2 * n + 1);
103 w3[2 * n] -= lmmp_sub_n_(w3, w3, w5, 2 * n);
104
105 /* W1 =(W1 - W3)/3 */
106 lmmp_sub_n_(w1, w1, w3, 2 * n + 1);
107 lmmp_divexact_by3_(w1, w1, 2 * n + 1);
108
109 cy = lmmp_add_n_(dst + n, dst + n, w4, 2 * n + 1);
110 lmmp_inc_1(dst + 3 * n + 1, cy);
111
112 /* W2 -= W0<<2 */
113 /* {W4,2*n+1} is now free and can be overwritten. */
114 cy = lmmp_shl_(w4, w0, w0n, 2);
115 cy += lmmp_sub_n_(w2, w2, w4, w0n);
116
117 lmmp_dec_1(w2 + w0n, cy);
118
119 /* W4L = W4L - W2L */
120 cy = lmmp_sub_n_(dst + n, dst + n, w2, n);
121 lmmp_dec_1(w3, cy);
122
123 /* W3H = W3H + W2L */
124 cy4 = w3[2 * n] + lmmp_add_n_(dst + 3 * n, dst + 3 * n, w2, n);
125 /* W1L + W2H */
126 cy = w2[2 * n] + lmmp_add_n_(dst + 4 * n, w1, w2 + n, n);
127 lmmp_inc_1(w1 + n, cy);
128
129 /* W0 = W0 + W1H */
130 if (w0n > n)
131 cy6 = w1[2 * n] + lmmp_add_n_(w0, w0, w1 + n, n);
132 else
133 cy6 = lmmp_add_n_(w0, w0, w1 + n, w0n);
134
135 cy = lmmp_sub_n_(dst + 2 * n, dst + 2 * n, dst + 4 * n, n + w0n);
136
137 /* embankment is a "dirty trick" to avoid carry/borrow propagation
138 beyond allocated memory */
139 embankment = w0[w0n - 1] - 1;
140 w0[w0n - 1] = 1;
141 if (w0n > n) {
142 if (cy4 > cy6)
143 lmmp_inc_1(dst + 4 * n, cy4 - cy6);
144 else
145 lmmp_dec_1(dst + 4 * n, cy6 - cy4);
146 lmmp_dec_1(dst + 3 * n + w0n, cy);
147 lmmp_inc_1(w0 + n, cy6);
148 } else {
149 lmmp_inc_1(dst + 4 * n, cy4);
150 lmmp_dec_1(dst + 3 * n + w0n, cy + cy6);
151 }
152 w0[w0n - 1] += embankment;
153
154#undef w5
155#undef w3
156#undef w0
157}
#define w3
#define w0
#define w5
#define w2

引用了 lmmp_add_n_(), lmmp_dec_1, lmmp_divexact_by3_(), lmmp_inc_1, lmmp_param_assert, lmmp_shl_(), lmmp_shr1add_n_(), lmmp_shr1sub_n_(), lmmp_shr_(), lmmp_sub_n_(), lmmp_toom_interp6_(), n, toom6_vm1_neg, toom6_vm2_neg, w0, w2, w3 , 以及 w5.

被这些函数引用 lmmp_mul_toom43_(), lmmp_mul_toom52_() , 以及 lmmp_toom_interp6_().

函数调用图:
这是这个函数的调用关系图:

◆ lmmp_toom_interp7_()

void lmmp_toom_interp7_ ( mp_ptr dst,
mp_size_t n,
enum toom7_flags flags,
mp_ptr w1,
mp_ptr w3,
mp_ptr w4,
mp_ptr w5,
mp_size_t w6n,
mp_ptr tp )

Toom插值计算(7点插值):用于Toom-44、Toom-53、Toom-62 乘法算法

Copyright (C) 2026 HJimmyK (Jericho Knox)

参数
dst输出结果缓冲区,存储插值计算结果(6*n + w6n limbs) w0 储存在[dst,2n], w2 储存在[dst+2n,2n+1], w6 储存在[dst+6n,w6n].
nToom-7 拆分后每段标准 limb 长度
flagsToom-7 符号标志位,控制插值中的正负号运算
w1输入/临时:点值 W1 缓冲区(2n+1 limbs)
w3输入/临时:点值 W3 缓冲区(2n+1 limbs)
w4输入/临时:点值 W4 缓冲区(2n+1 limbs)
w5输入/临时:点值 W5 缓冲区(2n+1 limbs)
w6n输入:最低位段 W6 的实际 limb 长度 (0 < w6n <= 2n)
tp临时缓存空间(2*n+1 limbs)
注解
w0=f(0), w1=f(-2), w2=f(1), w3=f(-1), w4=f(2), w5=64*f(1/2), w6=f(inf),
警告
n>0, 0<w6n<=2n, dst!=NULL, w1!=NULL, w3!=NULL, w4!=NULL, w5!=NULL, tp!=NULL

Toom插值计算(7点插值):用于Toom-44、Toom-53、Toom-62 乘法算法

This file is part of LMMP.

LMMP is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library. If not, see https://www.gnu.org/licenses/.

SPDX-License-Identifier: LGPL-3.0-or-later

在文件 mul_toom_interp7.c 第 62 行定义.

72 {
73 lmmp_param_assert(w6n > 0);
74 lmmp_param_assert(w6n <= 2 * n);
75 mp_size_t m;
76 mp_limb_t cy;
77
78 m = 2 * n + 1;
79#define w0 dst
80#define w2 (dst + 2 * n)
81#define w6 (dst + 6 * n)
82
83 lmmp_add_n_(w5, w5, w4, m);
84 if (flags & toom7_w1_neg) {
85 lmmp_shr1add_n_(w1, w1, w4, m);
86 } else {
87 lmmp_shr1sub_n_(w1, w4, w1, m);
88 }
89 lmmp_sub_(w4, w4, m, w0, 2 * n);
90 lmmp_sub_n_(w4, w4, w1, m);
91
92 lmmp_debug_assert(!(w4[0] & 3));
93
94 lmmp_shr_(w4, w4, m, 2); /* w4>=0 */
95
96 tp[w6n] = lmmp_shl_(tp, w6, w6n, 4);
97 lmmp_sub_(w4, w4, m, tp, w6n + 1);
98
99 if (flags & toom7_w3_neg) {
100 lmmp_shr1add_n_(w3, w3, w2, m);
101 } else {
102 lmmp_shr1sub_n_(w3, w2, w3, m);
103 }
104
105 lmmp_sub_n_(w2, w2, w3, m);
106
107 lmmp_submul_1_(w5, w2, m, 65);
108 lmmp_sub_(w2, w2, m, w6, w6n);
109 lmmp_sub_(w2, w2, m, w0, 2 * n);
110
111 lmmp_addmul_1_(w5, w2, m, 45);
112 lmmp_debug_assert(!(w5[0] & 1));
113 lmmp_shr_(w5, w5, m, 1);
114 lmmp_sub_n_(w4, w4, w2, m);
115
116 lmmp_divexact_by3_(w4, w4, m);
117 lmmp_sub_n_(w2, w2, w4, m);
118
119 lmmp_sub_n_(w1, w5, w1, m);
120 lmmp_shl_(tp, w3, m, 3);
121 lmmp_sub_n_(w5, w5, tp, m);
123 lmmp_sub_n_(w3, w3, w5, m);
124
125 lmmp_divexact_by15_(w1, w1, m);
126 lmmp_shr1add_n_(w1, w1, w5, m);
127 w1[m - 1] &= LIMB_MAX >> 1;
128
129 lmmp_sub_n_(w5, w5, w1, m);
130
131 /* These bounds are valid for the 4x4 polynomial product of toom44,
132 * and they are conservative for toom53 and toom62. */
133 lmmp_debug_assert(w1[2 * n] < 2);
134 lmmp_debug_assert(w2[2 * n] < 3);
135 lmmp_debug_assert(w3[2 * n] < 4);
136 lmmp_debug_assert(w4[2 * n] < 3);
137 lmmp_debug_assert(w5[2 * n] < 2);
138
139 cy = lmmp_add_n_(dst + n, dst + n, w1, m);
140 lmmp_inc_1(w2 + n + 1, cy);
141 cy = lmmp_add_n_(dst + 3 * n, dst + 3 * n, w3, n);
142 lmmp_inc_1(w3 + n, w2[2 * n] + cy);
143 cy = lmmp_add_n_(dst + 4 * n, w3 + n, w4, n);
144 lmmp_inc_1(w4 + n, w3[2 * n] + cy);
145 cy = lmmp_add_n_(dst + 5 * n, w4 + n, w5, n);
146 lmmp_inc_1(w5 + n, w4[2 * n] + cy);
147 if (w6n > n + 1) {
148 cy = lmmp_add_n_(dst + 6 * n, dst + 6 * n, w5 + n, n + 1);
149 lmmp_inc_1(dst + 7 * n + 1, cy);
150 } else {
151 cy = lmmp_add_n_(dst + 6 * n, dst + 6 * n, w5 + n, w6n);
152 lmmp_debug_assert(cy == 0);
153 }
154}
void lmmp_divexact_by9_(mp_ptr dst, mp_srcptr numa, mp_size_t na)
精确除以9([dst,na] = [numa,na] / 9)
void lmmp_divexact_by15_(mp_ptr dst, mp_srcptr numa, mp_size_t na)
精确除以15([dst,na] = [numa,na] / 15)
static mp_limb_t lmmp_sub_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_srcptr numb, mp_size_t nb)
减法静态内联函数 [dst,na]=[numa,na]-[numb,nb]
#define w6

引用了 LIMB_MAX, lmmp_add_n_(), lmmp_addmul_1_(), lmmp_debug_assert, lmmp_divexact_by15_(), lmmp_divexact_by3_(), lmmp_divexact_by9_(), lmmp_inc_1, lmmp_param_assert, lmmp_shl_(), lmmp_shr1add_n_(), lmmp_shr1sub_n_(), lmmp_shr_(), lmmp_sub_(), lmmp_sub_n_(), lmmp_submul_1_(), lmmp_toom_interp7_(), n, toom7_w1_neg, toom7_w3_neg, tp, w0, w2, w3, w5 , 以及 w6.

被这些函数引用 lmmp_mul_toom44_(), lmmp_mul_toom53_(), lmmp_mul_toom62_(), lmmp_mul_toom62_cache_(), lmmp_mul_toom62_cache_init_(), lmmp_sqr_toom4_() , 以及 lmmp_toom_interp7_().

函数调用图:
这是这个函数的调用关系图: