37 for (
size_t i = 0; i <
n; ++i) p[i] = pat;
42 mp_ptr dst = alloc_limbs(na + nb);
43 mp_ptr ref = alloc_limbs(na + nb + 1);
44 fn(dst, a, na, b, nb);
46 bool ok = memcmp(dst, ref, (
size_t)(na + nb) * 8) == 0;
47 if (!ok || !mod_is_product(dst, na + nb, a, na, b, nb))
TEST_CHECK_MSG(
false, tag);
57 kfn(
r1, a, na, b, nb);
67const double kRatios6[] = {1.0, 1.05, 1.15, 1.3, 1.32, 1.45, 1.48, 1.8, 1.88, 2.0, 2.11, 2.4, 2.6, 2.82};
69const double kRatios8[] = {1.0, 1.1, 1.22, 1.35, 1.5, 1.64, 1.8, 2.0, 2.24, 2.5, 2.85, 3.1, 3.5, 3.99};
74 return na >= nb && nb >= 46 && 6 * na < 17 * nb;
78 u64 seed = 0x6c6f666572746f6dull;
85 mp_ptr a = alloc_limbs(na), b = alloc_limbs(nb);
86 random_limbs(a, na, &seed);
87 random_limbs(b, nb, &seed);
98 u64 seed = 0x8a8f686967687475ull;
100 for (
mp_size_t nb = 86; nb <= 140; ++nb) {
104 if (na < nb || na > 4 * nb)
continue;
105 mp_ptr a = alloc_limbs(na), b = alloc_limbs(nb);
106 random_limbs(a, na, &seed);
107 random_limbs(b, nb, &seed);
118 u64 seed = 0x72713a736972716eull;
121 mp_ptr r1 = alloc_limbs(2 *
n),
r2 = alloc_limbs(2 *
n);
122 random_limbs(a,
n, &seed);
134 u64 seed = 0x33362e35392e3361ull;
136 if (
n == 57)
continue;
138 mp_ptr r1 = alloc_limbs(2 *
n),
r2 = alloc_limbs(2 *
n);
139 random_limbs(a,
n, &seed);
150TEST_CASE(
"mul/toom68", toom6h_oracle_balanced_and_unbalanced) {
151 u64 seed = 0x21726f74616d6f6full;
153 mp_size_t sizes[] = {43, 47, 55, 64, 73, 89};
154 for (
size_t nb_index = 0; nb_index <
ARRAY_SIZE(sizes); ++nb_index) {
156 const double r_values[] = {1.0, 1.32, 1.88, 2.82};
157 for (
size_t r_index = 0; r_index <
ARRAY_SIZE(r_values); ++r_index) {
158 double r = r_values[r_index];
161 mp_ptr a = alloc_limbs(na), b = alloc_limbs(nb);
162 random_limbs(a, na, &seed);
163 random_limbs(b, nb, &seed);
171TEST_CASE(
"mul/toom68", toom8h_oracle_balanced_and_unbalanced) {
172 u64 seed = 0x386f74206d6f6f6dull;
174 for (
size_t nb_index = 0; nb_index <
ARRAY_SIZE(sizes); ++nb_index) {
176 const double r_values[] = {1.0, 1.64, 2.85, 3.99};
177 for (
size_t r_index = 0; r_index <
ARRAY_SIZE(r_values); ++r_index) {
178 double r = r_values[r_index];
180 if (na > 4 * nb)
continue;
181 mp_ptr a = alloc_limbs(na), b = alloc_limbs(nb);
182 random_limbs(a, na, &seed);
183 random_limbs(b, nb, &seed);
191TEST_CASE(
"mul/toom68", thresholds_boundary_via_dispatch) {
192 u64 seed = 0x7468726573686f6cull;
194 struct threshold_case {
203 for (
size_t bd_index = 0; bd_index <
ARRAY_SIZE(bounds); ++bd_index) {
204 const struct threshold_case bd = bounds[bd_index];
205 for (
int d = -1; d <= 1; ++d) {
206 if (bd.base + (
mp_size_t)d < 1)
continue;
210 mp_ptr r = alloc_limbs(2 *
n), ref = alloc_limbs(2 *
n + 1);
211 random_limbs(a,
n, &seed);
214 bool ok = memcmp(r, ref, (
size_t)(2 *
n) * 8) == 0;
215 if (!ok || !mod_is_product(r, 2 *
n, a,
n, a,
n))
222 mp_ptr a = alloc_limbs(
n), b = alloc_limbs(
n);
223 mp_ptr r = alloc_limbs(2 *
n), ref = alloc_limbs(2 *
n + 1);
224 random_limbs(a,
n, &seed);
225 random_limbs(b,
n, &seed);
228 bool ok = memcmp(r, ref, (
size_t)(2 *
n) * 8) == 0;
229 if (!ok || !mod_is_product(r, 2 *
n, a,
n, b,
n))
241TEST_CASE(
"mul/toom68", extended_unbalanced_window_via_dispatch) {
244 u64 seed = 0x6e7562616c616e63ull;
246 const double r_values[] = {1.0, 1.2, 1.32, 1.6, 2.0, 2.5, 2.82, 3.2, 3.99};
247 for (
size_t r_index = 0; r_index <
ARRAY_SIZE(r_values); ++r_index) {
248 double r = r_values[r_index];
250 if (na >= 4 * nb0) na = 4 * nb0 - 1;
251 mp_ptr a = alloc_limbs(na), b = alloc_limbs(nb0);
252 random_limbs(a, na, &seed);
253 random_limbs(b, nb0, &seed);
261 u64 seed = 0x787472656d653031ull;
263 struct limb_pattern {
265 } pats[] = {{0x1111111111111111ull}, {
LIMB_MAX}};
266 for (
size_t pt_index = 0; pt_index <
ARRAY_SIZE(pats); ++pt_index) {
267 const struct limb_pattern pt = pats[pt_index];
269 for (
size_t nb_index = 0; nb_index <
ARRAY_SIZE(nb_values); ++nb_index) {
271 const double r_values[] = {1.0, 2.0, 2.8};
272 for (
size_t r_index = 0; r_index <
ARRAY_SIZE(r_values); ++r_index) {
273 double r = r_values[r_index];
276 mp_ptr a = alloc_limbs(na), b = alloc_limbs(nb);
285 for (
size_t nb_index = 0; nb_index <
ARRAY_SIZE(nb_values2); ++nb_index) {
287 const double r_values2[] = {1.0, 2.5, 3.9};
288 for (
size_t r_index = 0; r_index <
ARRAY_SIZE(r_values2); ++r_index) {
289 double r = r_values2[r_index];
291 if (na > 4 * nb)
continue;
292 mp_ptr a = alloc_limbs(na), b = alloc_limbs(nb);
301 for (
size_t n_index = 0; n_index <
ARRAY_SIZE(n_values); ++n_index) {
304 mp_ptr r1 = alloc_limbs(2 *
n),
r2 = alloc_limbs(2 *
n);
319 TEST_RUN(
"mul/toom68", toom6h_kernel_full_range);
320 TEST_RUN(
"mul/toom68", toom8h_kernel_full_range);
321 TEST_RUN(
"mul/toom68", sqr_toom6_kernel);
322 TEST_RUN(
"mul/toom68", sqr_toom8_kernel);
323 TEST_RUN(
"mul/toom68", toom6h_oracle_balanced_and_unbalanced);
324 TEST_RUN(
"mul/toom68", toom8h_oracle_balanced_and_unbalanced);
325 TEST_RUN(
"mul/toom68", thresholds_boundary_via_dispatch);
326 TEST_RUN(
"mul/toom68", extended_unbalanced_window_via_dispatch);
327 TEST_RUN(
"mul/toom68", extreme_patterns);
const mp_limb_t * mp_srcptr
void lmmp_free(void *ptr)
内存释放函数(调用lmmp_heap_free_fn)
mp_limb_t u64
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define SQR_TOOM6_THRESHOLD
#define MUL_TOOM8H_THRESHOLD
#define SQR_TOOM8_THRESHOLD
#define MUL_TOOM6H_THRESHOLD
void test_mul_toom68(void)
void lmmp_mul_toom6h_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_srcptr numb, mp_size_t nb)
Toom-6.5乘法运算 [dst,na+nb] = [numa,na] * [numb,nb] (非对称切分+条件inf点,原生支持不平衡;评估点 inf,±4,...
void lmmp_sqr_toom8_(mp_ptr dst, mp_srcptr numa, mp_size_t na)
Toom-8平方运算 [dst,2*na] = [numa,na]^2 (评估点 ±8,±4,±2,±1,±1/2,±1/4,±1/8,0,无inf点)
void lmmp_mul_basecase_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_srcptr numb, mp_size_t nb)
基础乘法运算 [dst,na+nb] = [numa,na] * [numb,nb]
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]
void lmmp_mul_toom8h_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_srcptr numb, mp_size_t nb)
Toom-8.5乘法运算 [dst,na+nb] = [numa,na] * [numb,nb] (非对称切分+条件inf点,原生支持不平衡;评估点 inf,±8,...
void lmmp_sqr_toom6_(mp_ptr dst, mp_srcptr numa, mp_size_t na)
Toom-6平方运算 [dst,2*na] = [numa,na]^2 (评估点 ±4,±2,±1,±1/2,±1/4,0,无inf点)
#define ARRAY_SIZE(a)
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define TEST_CHECK_MSG(cond, msg)
#define TEST_CASE(category, name)
#define TEST_RUN(category, name)
static void check_vs_dispatch(const char *tag, mp_ptr a, mp_size_t na, mp_ptr b, mp_size_t nb, void(*kfn)(mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t))
static void fill_pattern(mp_ptr p, size_t n, mp_limb_t pat)
Copyright (C) 2026 HJimmyK (Jericho Knox)
static void check_vs_oracle(const char *tag, mp_ptr a, mp_size_t na, mp_ptr b, mp_size_t nb, void(*fn)(mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t))
static bool in_6h_range(mp_size_t na, mp_size_t nb)