37TEST_CASE(
"low/addsub", add_sub_deterministic_inplace) {
39 const u64 av[5] = {UINT64_MAX - 1, 0, 0, 1, UINT64_MAX};
40 const u64 bv[5] = {1, 0, UINT64_MAX, UINT64_MAX - 1, 0};
41 mp_ptr a = alloc_limbs(
n), b = alloc_limbs(
n), d = alloc_limbs(
n), r = alloc_limbs(
n);
42 for (
mp_size_t i = 0; i <
n; ++i) { a[i] = av[i]; b[i] = bv[i]; }
67TEST_CASE(
"low/shift", shlnot_not_inplace_deterministic) {
70 0x0000000000000001ull, 0x8000000000000000ull,
71 0xffffffffffffffffull, 0x123456789abcdef0ull,
72 0x0fedcba987654321ull, 0xaaaaaaaa55555555ull
74 mp_ptr a = alloc_limbs(
n), orig = alloc_limbs(
n), r = alloc_limbs(
n);
75 for (
mp_size_t i = 0; i <
n; ++i) a[i] = vals[i];
76 memcpy(orig, a,
n * 8);
83 const mp_size_t s_values[] = {0, 1, 7, 31, 63};
84 for (
size_t s_index = 0; s_index <
ARRAY_SIZE(s_values); ++s_index) {
87 memcpy(a, orig,
n * 8);
95TEST_CASE(
"low/div", div_1_mod_1_boundary_deterministic) {
97 const u64 fills[] = {0ull, 1ull, ~0ull};
98 const u64 divisors[] = {1ull, 2ull, 0x8000000000000000ull, ~0ull};
99 for (
size_t n_index = 0; n_index <
ARRAY_SIZE(ns); ++n_index) {
101 for (
size_t fill_index = 0; fill_index <
ARRAY_SIZE(fills); ++fill_index) {
102 u64 fill = fills[fill_index];
103 mp_ptr a = alloc_limbs(
n), q = alloc_limbs(
n + 1),
t = alloc_limbs(
n + 2);
104 for (
mp_size_t i = 0; i <
n; ++i) a[i] = (i ==
n - 1) ? fill : (fill >> 1);
105 for (
size_t x_index = 0; x_index <
ARRAY_SIZE(divisors); ++x_index) {
106 u64 x = divisors[x_index];
112 add_small_inplace(
t,
n + 1, rem);
120TEST_CASE(
"low/addsub", addshl1_subshl1_boundary_deterministic) {
122 const u64 av[4] = {0, 1, ~(
u64)0 - 1, 3};
123 const u64 bv[4] = {(
u64)1 << 63, ~(
u64)0, 0, 2};
124 mp_ptr a = alloc_limbs(
n), b = alloc_limbs(
n), d = alloc_limbs(
n + 1),
t = alloc_limbs(
n + 1),
125 b2 = alloc_limbs(
n + 1);
126 for (
mp_size_t i = 0; i <
n; ++i) { a[i] = av[i]; b[i] = bv[i]; }
143 TEST_RUN(
"low/addsub", add_sub_deterministic_inplace);
144 TEST_RUN(
"low/shift", shlnot_not_inplace_deterministic);
145 TEST_RUN(
"low/div", div_1_mod_1_boundary_deterministic);
146 TEST_RUN(
"low/addsub", addshl1_subshl1_boundary_deterministic);
void lmmp_free(void *ptr)
内存释放函数(调用lmmp_heap_free_fn)
mp_limb_t u64
Copyright (C) 2026 HJimmyK (Jericho Knox)
void test_deterministic_extra(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_1_(mp_ptr dstq, mp_srcptr numa, mp_size_t na, mp_limb_t x)
单精度数除法
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)
mp_limb_t lmmp_mod_1_(mp_srcptr numa, mp_size_t na, mp_limb_t x)
单精度数取余
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)
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
void lmmp_not_(mp_ptr dst, mp_srcptr numa, mp_size_t na)
按位取反操作 [dst,na] = ~[numa,na] (对每个limb执行按位非操作)
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]
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]
#define ARRAY_SIZE(a)
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define TEST_CASE(category, name)
#define TEST_CHECK_EQ(a, b)
#define TEST_RUN(category, name)