LMMP 4.3.0
Lamina High-Precision Arithmetic Library
载入中...
搜索中...
未找到
test_asm_functions.c
浏览该文件的文档.
1/**
2 * Copyright (C) 2026 HJimmyK (Jericho Knox)
3 *
4 * This file is part of LMMP.
5 *
6 * LMMP is free software: you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as
8 * published by the Free Software Foundation; either version 3 of
9 * the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library. If not, see
18 * <https://www.gnu.org/licenses/>.
19 *
20 * SPDX-License-Identifier: LGPL-3.0-or-later
21 */
22
23#include "lmmp/lmmpn.h"
24#include "mparam.h"
25#include "cases.h"
27
28#include <string.h>
29
30/*
31 全部用库内组合恒等式验证:add_nc == add_n 再补 c、div 系列用
32 q*d + r == n 重建(乘法用 mul_1/mul,加法用 add_n)。
33*/
34
35TEST_CASE("asm/addsub", add_nc_sub_nc_random) {
36 u64 seed = 0xa11ce01234567890ull;
37 for (mp_size_t n = 1; n <= 65; ++n) {
38 for (int iter = 0; iter < 20; ++iter) {
39 mp_ptr a = alloc_limbs(n), b = alloc_limbs(n), d = alloc_limbs(n), t = alloc_limbs(n);
40 random_limbs_with_top(a, n, &seed, false); // 高位允许为零(非归一化输入)
41 random_limbs_with_top(b, n, &seed, false);
42
43 u64 carry0 = lmmp_add_nc_(t, a, b, n, 0);
44 u64 borrow0 = lmmp_sub_nc_(t, a, b, n, 0);
45 const u64 c_values[] = {0u, 1u};
46 for (size_t c_index = 0; c_index < ARRAY_SIZE(c_values); ++c_index) {
47 u64 c = c_values[c_index];
48 // add_nc(a,b,c) == add_n(a,b) 再 +c
49 u64 cy = lmmp_add_nc_(d, a, b, n, c);
50 mp_ptr e = alloc_limbs(n);
51 lmmp_add_n_(e, a, b, n);
52 u64 ovf = c ? add_small_inplace(e, n, 1) : 0;
53 TEST_CHECK_EQ(memcmp(d, e, n * 8), 0);
54 TEST_CHECK_EQ(cy, carry0 + ovf);
55
56 // sub_nc(a,b,c) == sub_n(a,b) 再 -c
57 u64 bw = lmmp_sub_nc_(d, a, b, n, c);
58 lmmp_sub_n_(e, a, b, n);
59 u64 unf = c ? sub_small_inplace(e, n, 1) : 0;
60 TEST_CHECK_EQ(memcmp(d, e, n * 8), 0);
61 TEST_CHECK_EQ(bw, borrow0 + unf);
62 lmmp_free(e);
63 }
64
66 }
67 }
68}
69
70TEST_CASE("asm/mul1", mul_1_addmul_submul_random_inplace) {
71 u64 seed = 0xb0b0c0d0e0f01020ull;
72 for (mp_size_t n = 1; n <= 65; ++n) {
73 for (int iter = 0; iter < 20; ++iter) {
74 mp_ptr a = alloc_limbs(n), d = alloc_limbs(n + 1), t = alloc_limbs(n + 2),
75 acc = alloc_limbs(n + 1), acc2 = alloc_limbs(n + 1);
76 random_limbs_with_top(a, n, &seed, false);
77 u64 x = xorshift64(&seed) | 1;
78
79 // mul_1 与 div_1 互逆重建
80 u64 cy = lmmp_mul_1_(d, a, n, x);
81 d[n] = cy;
82 u64 rem = lmmp_div_1_(t, d, n + 1, x);
83 TEST_CHECK_EQ(rem, 0ull);
84 TEST_CHECK(mpn_eq(t, n + 1, a, n));
85
86 // in-place mul_1(a2,a2) 与分离调用一致
87 mp_ptr a2 = alloc_limbs(n);
88 memcpy(a2, a, n * 8);
89 memcpy(d, a, n * 8);
90 u64 cy2 = lmmp_mul_1_(a2, a2, n, x);
91 u64 cy_ref = lmmp_mul_1_(d, a, n, x);
92 TEST_CHECK_EQ(cy2, cy_ref);
93 TEST_CHECK_EQ(memcmp(a2, d, n * 8), 0);
94 TEST_CHECK_EQ(cy2, cy); // 与首段同输入同输出
95
96 // addmul_1 == mul_1 后 add_n(两路径)
97 random_limbs_with_top(acc, n, &seed, false);
98 memcpy(acc2, acc, n * 8);
99 acc2[n] = 0;
100 u64 mcy = lmmp_mul_1_(d, a, n, x);
101 u64 c1 = lmmp_add_n_(t, acc, d, n) + mcy; // 进位=加进位+乘进位
102 u64 c2 = lmmp_addmul_1_(acc2, a, n, x);
103 TEST_CHECK_EQ(memcmp(acc2, t, n * 8), 0);
104 TEST_CHECK_EQ(c2, c1);
105
106 // in-place addmul_1(acc2, acc2):x*acc + acc
107 memcpy(acc2, acc, n * 8);
108 acc2[n] = 0;
109 u64 mcyb = lmmp_mul_1_(d, acc, n, x);
110 u64 c1b = lmmp_add_n_(t, acc, d, n) + mcyb;
111 u64 c2b = lmmp_addmul_1_(acc2, acc2, n, x);
112 TEST_CHECK_EQ(memcmp(acc2, t, n * 8), 0);
113 TEST_CHECK_EQ(c2b, c1b);
114
115 // submul_1 == sub_n(acc, mul_1 积),借位复合
116 memcpy(acc2, acc, n * 8);
117 acc2[n] = 0;
118 lmmp_mul_1_(d, a, n, x);
119 u64 w = lmmp_sub_n_(t, acc, d, n);
120 u64 hi = cy; // mul_1 高位(同 a、x)
121 u64 c3 = lmmp_submul_1_(acc2, a, n, x);
122 TEST_CHECK_EQ(memcmp(acc2, t, n * 8), 0);
123 TEST_CHECK_EQ(c3, w + hi);
124
125 // in-place submul_1(acc2, acc2)
126 memcpy(acc2, acc, n * 8);
127 acc2[n] = 0;
128 u64 hi2 = lmmp_mul_1_(d, acc, n, x);
129 u64 w2 = lmmp_sub_n_(t, acc, d, n);
130 u64 c3b = lmmp_submul_1_(acc2, acc2, n, x);
131 TEST_CHECK_EQ(memcmp(acc2, t, n * 8), 0);
132 TEST_CHECK_EQ(c3b, w2 + hi2);
133
135 }
136 }
137}
138
140 // 被测:asm/C addmul_2,契约为 [rp,n+1] 覆写 rp[n] + 返回第 n+1 limb
141 mp_ptr r1 = alloc_limbs(n + 3), r2 = alloc_limbs(n + 3), r3 = alloc_limbs(n + 3),
142 t = alloc_limbs(n + 2);
143 mp_ptr vv = alloc_limbs(2);
144 vv[0] = v0; vv[1] = v1;
145 memset(r1, 0xCC, (n + 3) * 8);
146 memcpy(r1, rp, n * 8);
147 mp_limb_t tail0 = r1[n + 2];
148 u64 ret1 = lmmp_addmul_2_(r1, a, n, vv);
149
150 // 参考 1:两遍 addmul_1 组合(同计算另一路径)
151 memset(r2, 0xCC, (n + 3) * 8);
152 memcpy(r2, rp, n * 8);
153 r2[n] = 0;
154 mp_limb_t cy0 = lmmp_addmul_1_(r2, a, n, v0);
155 mp_limb_t cy1 = lmmp_addmul_1_(r2 + 1, a, n, v1);
156 mp_limb_t hn = r2[n] + cy0;
157 r2[n] = hn;
158 u64 ret2 = cy1 + (mp_limb_t)(hn < cy0);
159
160 // 参考 2:mul_ 全乘 + add_n 组合(n==1 时换算子序保持 na>=nb)
161 if (n == 1) lmmp_mul_(t, vv, 2, a, 1);
162 else lmmp_mul_(t, a, n, vv, 2);
163 mp_limb_t c = lmmp_add_n_(r3, rp, t, n);
164 mp_limb_t e2 = t[n] + c;
165 r3[n] = e2;
166 u64 ret3 = t[n + 1] + (mp_limb_t)(e2 < c);
167
168 TEST_CHECK_EQ(memcmp(r1, r2, (n + 1) * 8), 0);
169 TEST_CHECK_EQ(ret1, ret2);
170 TEST_CHECK_EQ(memcmp(r1, r3, (n + 1) * 8), 0);
171 TEST_CHECK_EQ(ret1, ret3);
172 // 写入长度契约:n+2 limb 之外不得写
173 TEST_CHECK_EQ(r1[n + 2], tail0);
174
175 // eqsep 原位形态:与同值分离形(r4=a 值拷贝,numb 仍读 a)交叉
176 mp_ptr r4 = alloc_limbs(n + 1), a2 = alloc_limbs(n + 1);
177 memcpy(r4, a, n * 8);
178 memcpy(a2, a, n * 8);
179 u64 ret4 = lmmp_addmul_2_(r4, r4, n, vv);
180 u64 ret5 = lmmp_addmul_2_(a2, a, n, vv);
181 TEST_CHECK_EQ(ret4, ret5);
182 TEST_CHECK_EQ(memcmp(r4, a2, (n + 1) * 8), 0);
183
185 lmmp_free(t); lmmp_free(vv);
186}
187
188TEST_CASE("asm/addmul2", addmul_2_vs_composition_and_fullmul) {
189 u64 seed = 0xa44a2badcafe01ull;
190
191 for (mp_size_t n = 1; n <= 65; ++n) {
192 for (int iter = 0; iter < 16; ++iter) {
193 mp_ptr a = alloc_limbs(n), rp = alloc_limbs(n);
194 random_limbs_with_top(a, n, &seed, false);
195 random_limbs_with_top(rp, n, &seed, false);
196 mp_limb_t v[2] = {xorshift64(&seed) | 1, xorshift64(&seed) | 1};
197 check_addmul_2(a, rp, n, v[0], v[1]);
199 }
200 }
201 // 极端输入:全 FF / 全 0 / v 极值(进位保存不变量边界情形)
202 for (mp_size_t n = 1; n <= 33; ++n) {
203 mp_ptr a = alloc_limbs(n), rp = alloc_limbs(n);
204 memset(a, 0xFF, n * 8);
205 memset(rp, 0xFF, n * 8);
206 check_addmul_2(a, rp, n, ~(mp_limb_t)0, ~(mp_limb_t)0);
207 memset(rp, 0, n * 8);
208 check_addmul_2(a, rp, n, ~(mp_limb_t)0, ~(mp_limb_t)0);
209 memset(a, 0, n * 8);
210 check_addmul_2(a, rp, n, ~(mp_limb_t)0, 1);
211 check_addmul_2(a, rp, n, 1, ~(mp_limb_t)0);
213 }
214}
215
216TEST_CASE("asm/shift", shl_shr_carry_random) {
217 u64 seed = 0xc1c2c3c4c5c6c7c8ull;
218 for (mp_size_t n = 1; n <= 17; ++n) {
219 for (int iter = 0; iter < 5; ++iter) {
220 mp_ptr a = alloc_limbs(n), d = alloc_limbs(n), tsh = alloc_limbs(n),
221 tshr = alloc_limbs(n);
222 random_limbs_with_top(a, n, &seed, false);
223
224 for (mp_size_t s = 0; s < 64; ++s) {
225 // 独立基准:shl 与 shr 各自缓冲(互逆性由 low/shift 覆盖)
226 u64 r1 = lmmp_shl_(tsh, a, n, s);
227 u64 r2 = lmmp_shr_(tshr, a, n, s);
228 u64 lowmask = s ? (((u64)1 << s) - 1) : 0;
229
230 // shl_c:body == shl(limb[1,n) 与 limb0 高位一致),
231 // 低 s 位为注入的 c,返回同 shl
232 u64 c_shl = s ? (xorshift64(&seed) & lowmask) : 0;
233 u64 r3 = lmmp_shl_c_(d, a, n, s, c_shl);
234 if (n > 1) TEST_CHECK_EQ(memcmp(d + 1, tsh + 1, (n - 1) * 8), 0);
235 if (s) {
236 TEST_CHECK_EQ(d[0] & lowmask, c_shl);
237 TEST_CHECK_EQ(d[0] >> s, tsh[0] >> s);
238 } else {
239 TEST_CHECK_EQ(memcmp(d, tsh, n * 8), 0);
240 }
242
243 // shr_c:body == shr(limb[0,n-1) 一致 + 顶 limb 低位一致),
244 // 顶 s 位为注入的 c(已置于高位),返回同 shr
245 u64 c_shr = s ? (xorshift64(&seed) << (64 - s)) : 0;
246 u64 topmask = s ? (~0ull << (64 - s)) : 0;
247 u64 r4 = lmmp_shr_c_(d, a, n, s, c_shr);
248 if (n > 1) TEST_CHECK_EQ(memcmp(d, tshr, (n - 1) * 8), 0);
249 TEST_CHECK_EQ(d[n - 1] & ~topmask, tshr[n - 1] & ~topmask);
250 if (s) TEST_CHECK_EQ(d[n - 1] & topmask, c_shr & topmask);
252 }
253
254 lmmp_free(a); lmmp_free(d); lmmp_free(tsh); lmmp_free(tshr);
255 }
256 }
257}
258
259TEST_CASE("asm/shift", shlnot_not_addshl1_subshl1_random) {
260 u64 seed = 0xd1d2d3d4d5d6d7d8ull;
261 for (mp_size_t n = 1; n <= 65; ++n) {
262 for (int iter = 0; iter < 10; ++iter) {
263 mp_ptr a = alloc_limbs(n), b = alloc_limbs(n), d = alloc_limbs(n + 1),
264 t = alloc_limbs(n + 1), b2 = alloc_limbs(n + 1);
265 random_limbs_with_top(a, n, &seed, false);
266 random_limbs_with_top(b, n, &seed, false);
267
268 lmmp_not_(d, a, n);
269 for (mp_size_t i = 0; i < n; ++i) TEST_CHECK_EQ(d[i], ~a[i]);
270
271 for (mp_size_t s = 0; s < 64; ++s) {
272 u64 r1 = lmmp_shl_(t, a, n, s);
273 u64 ret = lmmp_shlnot_(d, a, n, s);
274 lmmp_not_(b2, t, n);
275 TEST_CHECK_EQ(memcmp(d, b2, n * 8), 0);
276 TEST_CHECK_EQ(ret, r1); // 返回移出位与 shl 一致(不取反)
277 }
278
279 // addshl1_n == a + 2b(复合路径),进位复合 c1+c2
280 u64 c1 = lmmp_add_n_(b2, b, b, n);
281 u64 c2 = lmmp_add_n_(t, a, b2, n);
282 u64 cy = lmmp_addshl1_n_(d, a, b, n);
283 TEST_CHECK_EQ(memcmp(d, t, n * 8), 0);
284 TEST_CHECK_EQ(cy, c1 + c2);
285
286 // subshl1_n == a - 2b(模 B^n 语义),借位复合 w1+c1
287 u64 w1 = lmmp_sub_n_(t, a, b2, n);
288 u64 bw = lmmp_subshl1_n_(d, a, b, n);
289 TEST_CHECK_EQ(memcmp(d, t, n * 8), 0);
290 TEST_CHECK_EQ(bw, w1 + c1);
291
293 }
294 }
295}
296
297/*
298 shr1add_nc / shr1sub_nc:先算 (a±(b+c))(add_nc/sub_nc 路径),再右移
299 1 位;进位/借位落位于结果顶位,返回值为差/和的最低位。
300*/
301TEST_CASE("asm/rsh1", shr1add_shr1sub_random) {
302 u64 seed = 0xe1e2e3e4e5e6e7e8ull;
303 for (mp_size_t n = 1; n <= 65; ++n) {
304 for (int iter = 0; iter < 20; ++iter) {
305 mp_ptr a = alloc_limbs(n), b = alloc_limbs(n), d = alloc_limbs(n), t = alloc_limbs(n);
306 random_limbs_with_top(a, n, &seed, false);
307 random_limbs_with_top(b, n, &seed, false);
308
309 const u64 c_values[] = {0u, 1u};
310 for (size_t c_index = 0; c_index < ARRAY_SIZE(c_values); ++c_index) {
311 u64 c = c_values[c_index];
312 u64 cout = lmmp_add_nc_(t, a, b, n, c);
313 u64 l = lmmp_shr1add_nc_(d, a, b, n, c);
314 u64 low = shr1_inplace(t, n, cout);
315 TEST_CHECK_EQ(memcmp(d, t, n * 8), 0);
316 TEST_CHECK_EQ(l, low);
317
318 u64 bout = lmmp_sub_nc_(t, a, b, n, c);
319 u64 l2 = lmmp_shr1sub_nc_(d, a, b, n, c);
320 u64 low2 = shr1_inplace(t, n, bout);
321 TEST_CHECK_EQ(memcmp(d, t, n * 8), 0);
322 TEST_CHECK_EQ(l2, low2);
323 }
324
326 }
327 }
328}
329
330/*
331 div_3_2:用库 mul_1 + add 构造 n = q*d + r(q < B、MSB(d)=1、r < d,
332 则 n < B^3),判决须还原 q 并把 [np,2] 改写为 r。
333*/
334TEST_CASE("asm/div", div_3_2_random) {
335 u64 seed = 0xf1f2f3f4f5f6f7f8ull;
336 for (int iter = 0; iter < 500; ++iter) {
337 mp_ptr np = alloc_limbs(3), npw = alloc_limbs(3), dp = alloc_limbs(2);
338 dp[1] = xorshift64(&seed) | LIMB_B_2;
339 dp[0] = xorshift64(&seed);
340 u64 q = xorshift64(&seed);
341 u64 r = dp[0] - 1; // 单 limb 余数,恒 < d(d >= 2^63*B > B > r)
342
343 // np = q*d + r(q*d 经 mul_1 得 3 limbs,再 + r)
344 np[0] = dp[0];
345 np[1] = dp[1];
346 u64 hi = lmmp_mul_1_(np, np, 2, q);
347 np[2] = hi;
348 add_small_inplace(np, 3, r);
349
350 mp_limb_t inv21 = lmmp_inv_2_1_(dp[1], dp[0]);
351 memcpy(npw, np, 3 * 8);
352 mp_limb_t qq = lmmp_div_3_2_(npw, dp, inv21);
353 TEST_CHECK_EQ(qq, q);
354 TEST_CHECK_EQ(npw[0], r);
355 TEST_CHECK_EQ(npw[1], 0ull);
356
357 lmmp_free(np); lmmp_free(npw); lmmp_free(dp);
358 }
359}
360
361/*
362 div_1/mod_1:恒等式 q*x + r == a 且 r < x;mod_1 与 div_1 余数一致;
363 div_1_s 与 div_1 同输入同结果(破坏性入参上重建)。
364*/
365TEST_CASE("asm/div", div_1_mod_1_random_extra) {
366 u64 seed = 0x0123456789abcdefull;
367 for (mp_size_t n = 1; n <= 70; ++n) {
368 for (int iter = 0; iter < 10; ++iter) {
369 mp_ptr a = alloc_limbs(n), q = alloc_limbs(n + 1), t = alloc_limbs(n + 2),
370 a2 = alloc_limbs(n);
371 random_limbs_with_top(a, n, &seed, false);
372 u64 x = xorshift64(&seed) | 1;
373
374 u64 r_mod = lmmp_mod_1_(a, n, x);
375 u64 r_div = lmmp_div_1_(q, a, n, x);
376 TEST_CHECK_EQ(r_mod, r_div);
377 TEST_CHECK(r_div < x);
378
379 // 重建:q*x + r == a
380 u64 hi = lmmp_mul_1_(t, q, n, x);
381 t[n] = hi;
382 add_small_inplace(t, n + 1, r_div);
383 TEST_CHECK(mpn_eq(t, n + 1, a, n));
384
385 // div_1_s 与 div_1 一致(MSB(x)=1 档):qh:[qs,n-1] 合成完整商
386 if (n > 1 && (x | LIMB_B_2) == x) {
387 memcpy(a2, a, n * 8);
388 mp_ptr qs = alloc_limbs(n + 1);
389 u64 qh = lmmp_div_1_s_(qs, a2, n, x);
390 u64 rs = a2[0];
391 TEST_CHECK_EQ(memcmp(qs, q, (n - 1) * 8), 0);
392 TEST_CHECK_EQ(qh, q[n - 1]);
393 TEST_CHECK_EQ(rs, r_div);
394 lmmp_free(qs);
395 }
396
398 }
399 }
400}
401
402/*
403 div_2/mod_2:恒等式 q*d + r == a(mul 重建)且 r < d;三个入口
404 (div_2、mod_2、div_2_s)结果互相一致。
405*/
406TEST_CASE("asm/div", div_2_mod_2_random_extra) {
407 u64 seed = 0x0badf00dcafefaceull;
408 for (mp_size_t n = 2; n <= 40; ++n) {
409 for (int iter = 0; iter < 10; ++iter) {
410 mp_ptr a = alloc_limbs(n), q = alloc_limbs(n + 1), b = alloc_limbs(2),
411 b2 = alloc_limbs(2), a2 = alloc_limbs(n), t = alloc_limbs(n + 2);
412 random_limbs_with_top(a, n, &seed, false);
413 b[1] = xorshift64(&seed) | LIMB_B_2;
414 b[0] = xorshift64(&seed);
415
416 // mod_2(余数写入 numb;div_2 会复用 b2,先保存)
417 memcpy(a2, a, n * 8);
418 memcpy(b2, b, 2 * 8);
419 lmmp_mod_2_(a2, n, b2);
420 mp_limb_t modrem[2] = {b2[0], b2[1]};
421
422 // div_2:商 [q, n-1],余数写回 [b2,2]
423 memcpy(b2, b, 2 * 8);
424 lmmp_div_2_(q, a, n, b2);
425 TEST_CHECK(mpn_eq(b2, 2, modrem, 2)); // 两入口余数一致
426 TEST_CHECK(mpn_cmp(b2, 2, b, 2) < 0); // r < d
427
428 // 重建:q*d + r == a(n==2 时商为单 limb,用 mul_1)
429 if (n == 2) {
430 u64 hi = lmmp_mul_1_(t, b, 2, q[0]);
431 t[2] = hi;
432 } else {
433 lmmp_mul_(t, q, n - 1, b, 2);
434 }
435 add_small_inplace(t, n + 1, b2[0]);
436 add_small_inplace(t + 1, n, b2[1]); // 进位不可能(和 < B^(n+1))
437 TEST_CHECK(mpn_eq(t, n + 1, a, n));
438
439 // div_2_s 与 div_2 一致:qh:[qs,n-2] 合成完整商(先存余数再覆写)
440 if (n > 2) {
441 u64 rem0 = b2[0], rem1 = b2[1];
442 memcpy(a2, a, n * 8);
443 memcpy(b2, b, 2 * 8);
444 mp_ptr qs = alloc_limbs(n + 1);
445 mp_limb_t qh = lmmp_div_2_s_(qs, a2, n, b2);
446 TEST_CHECK_EQ(memcmp(qs, q, (n - 2) * 8), 0);
447 TEST_CHECK_EQ(qh, q[n - 2]);
448 TEST_CHECK_EQ(a2[0], rem0);
449 TEST_CHECK_EQ(a2[1], rem1);
450 lmmp_free(qs);
451 }
452
454 }
455 }
456}
457
458/*
459 inv_1 契约:x*(B+inv) ∈ (B^2-1-x, B^2-1]。积用 mul_1 取双 limb,
460 x*B 部分折进高 limb(无溢出:积 < B^2)。
461*/
462TEST_CASE("asm/inv", inv_1_inv_2_1_random) {
463 u64 seed = 0x1111222233334444ull;
464 for (int i = 0; i < 2000; ++i) {
465 u64 x = xorshift64(&seed) | LIMB_B_2;
466 u64 inv = lmmp_inv_1_(x);
467 mp_limb_t prod[2];
468 u64 hi = lmmp_mul_1_(prod, &x, 1, inv); // prod = x*inv 双 limb
469 prod[1] = hi;
470 u64 p_hi = prod[1] + x; // + x*B 的高半(不溢出)
471 u64 p_lo = prod[0];
472 // prod <= B^2-1 且 > B^2-1-x
473 TEST_CHECK_EQ(p_hi, ~(u64)0);
474 TEST_CHECK(p_lo >= (u64)(0 - x));
475
476 u64 xh = xorshift64(&seed) | LIMB_B_2;
477 u64 xl = xorshift64(&seed);
478 mp_limb_t inv21 = lmmp_inv_2_1_(xh, xl);
479 TEST_CHECK_MSG(inv21 != 0, "inv_2_1 nonzero");
480 }
481}
482
484 TEST_RUN("asm/addsub", add_nc_sub_nc_random);
485 TEST_RUN("asm/mul1", mul_1_addmul_submul_random_inplace);
486 TEST_RUN("asm/addmul2", addmul_2_vs_composition_and_fullmul);
487 TEST_RUN("asm/shift", shl_shr_carry_random);
488 TEST_RUN("asm/shift", shlnot_not_addshl1_subshl1_random);
489 TEST_RUN("asm/rsh1", shr1add_shr1sub_random);
490 TEST_RUN("asm/div", div_3_2_random);
491 TEST_RUN("asm/div", div_1_mod_1_random_extra);
492 TEST_RUN("asm/div", div_2_mod_2_random_extra);
493 TEST_RUN("asm/inv", inv_1_inv_2_1_random);
494}
#define prod
#define rp
#define LIMB_B_2
mp_limb_t * mp_ptr
定义 lmmp.h:96
uint64_t mp_size_t
定义 lmmp.h:93
const mp_limb_t * mp_srcptr
定义 lmmp.h:97
void lmmp_free(void *ptr)
内存释放函数(调用lmmp_heap_free_fn)
uint64_t mp_limb_t
定义 lmmp.h:92
mp_limb_t u64
Copyright (C) 2026 HJimmyK (Jericho Knox)
void test_asm_functions(void)
mp_limb_t lmmp_shlnot_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t shl)
左移后按位取反操作 [dst,na] = ~([numa,na] << shl),dst的低shl位填充1
mp_limb_t lmmp_div_3_2_(mp_ptr numa, mp_srcptr numb, mp_limb_t inv21)
3/2位除法运算 [numa,2]=[numa,3] mod [numb,2]
mp_limb_t lmmp_div_1_s_(mp_ptr dstq, mp_ptr numa, mp_size_t na, mp_limb_t x)
单精度数除法(除数为1个limb)
mp_limb_t lmmp_div_1_(mp_ptr dstq, mp_srcptr numa, mp_size_t na, mp_limb_t x)
单精度数除法
定义 div.c:137
mp_limb_t lmmp_shr1add_nc_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n, mp_limb_t c)
带进位加法后右移1位 [dst,n] = ([numa,n] + [numb,n] + c) >> 1
定义 shr.c:53
mp_limb_t lmmp_shr_c_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t shr, mp_limb_t c)
带进位的右移操作 [dst,na] = [numa,na]>>shr,dst的高shr位填充c的高shr位
定义 shr.c:39
mp_limb_t lmmp_addmul_2_(mp_ptr numa, mp_srcptr numb, mp_size_t n, mp_srcptr bp)
乘以双limb并累加 [numa,n] += [numb,n] * [bp,2]
定义 mul_1.c:99
void lmmp_div_2_(mp_ptr dstq, mp_srcptr numa, mp_size_t na, mp_ptr numb)
双精度数除法 (除数为2个limb)
定义 div.c:294
mp_limb_t lmmp_subshl1_n_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n)
减法结合左移1位操作 [dst,n] = [numa,n] - ([numb,n] << 1)
定义 shl.c:80
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_mod_1_(mp_srcptr numa, mp_size_t na, mp_limb_t x)
单精度数取余
定义 div.c:38
void lmmp_mod_2_(mp_srcptr numa, mp_size_t na, mp_ptr numb)
双精度数取余 (除数为2个limb)
定义 div.c:215
void lmmp_mul_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_srcptr numb, mp_size_t nb)
不等长乘法操作 [dst,na+nb] = [numa,na] * [numb,nb]
mp_limb_t lmmp_shl_c_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t shl, mp_limb_t c)
带进位的左移操作 [dst,na] = [numa,na]<<shl,dst的低shl位填充c的低shl位
定义 shl.c:39
mp_limb_t lmmp_addshl1_n_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n)
加法结合左移1位操作 [dst,n] = [numa,n] + ([numb,n] << 1)
定义 shl.c:53
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
mp_limb_t lmmp_shr1sub_nc_(mp_ptr dst, mp_srcptr numa, mp_srcptr numb, mp_size_t n, mp_limb_t c)
带借位减法后右移1位 [dst,n] = ([numa,n] - [numb,n] - c) >> 1
定义 shr.c:69
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
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
mp_limb_t lmmp_mul_1_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_limb_t x)
乘以单limb操作 [dst,na] = [numa,na] * x
定义 mul_1.c:27
mp_limb_t lmmp_div_2_s_(mp_ptr dstq, mp_ptr numa, mp_size_t na, mp_srcptr numb)
双精度数除法(除数为2个limb)
void lmmp_not_(mp_ptr dst, mp_srcptr numa, mp_size_t na)
按位取反操作 [dst,na] = ~[numa,na] (对每个limb执行按位非操作)
定义 not.c:26
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
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_inv_1_(mp_limb_t x)
1阶逆元计算 (inv1)
定义 inv.c:124
mp_limb_t lmmp_inv_2_1_(mp_limb_t xh, mp_limb_t xl)
2-1阶逆元计算 (inv21)
定义 inv.c:27
mp_limb_t lmmp_sub_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
定义 sub_n.c:67
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 v0
#define r2
#define r1
#define a2
#define v1
#define r3
#define b2
#define t
#define s
#define n
#define r4
#define w2
#define c1
#define ARRAY_SIZE(a)
Copyright (C) 2026 HJimmyK (Jericho Knox)
定义 perf.h:40
#define TEST_CHECK(cond)
定义 test.h:37
#define TEST_CHECK_MSG(cond, msg)
定义 test.h:38
#define TEST_CASE(category, name)
定义 test.h:35
#define TEST_CHECK_EQ(a, b)
定义 test.h:39
#define TEST_RUN(category, name)
定义 test.h:36
static void check_addmul_2(mp_srcptr a, mp_srcptr rp, mp_size_t n, mp_limb_t v0, mp_limb_t v1)