48 mp_ptr work = alloc_limbs(
n + 1), q = alloc_limbs(
n + 1);
50 memcpy(work, x, (
size_t)
n * 8);
55 memcpy(work, q, (
size_t)wn * 8);
56 while (wn > 0 && work[wn - 1] == 0) --wn;
69 add_small_inplace(val, cap, d[i]);
71 return norm_len(val, cap);
89 snprintf(buf,
sizeof(buf),
"%016llx", (
unsigned long long)x[i]);
90 for (
size_t j = 0; j < 16; ++j) {
92 out[16 * i + j] = upper ? (char)toupper((
unsigned char)c) : c;
97 return (bits + 3) / 4;
107 for (
int upper = 0; upper <= 1; ++upper) {
108 char* got = (
char*)
lmmp_alloc((
size_t)digits + 8);
112 TEST_CHECK_MSG(memcmp(got, reference, digits) == 0,
"to_hex vs reference");
113 if (norm_len(x,
n) > 0)
TEST_CHECK_MSG(got[digits - 1] !=
'0',
"to_hex no leading zero");
121 (i & 1) ? (char)toupper((
unsigned char)got[(
size_t)i]) : got[(size_t)i];
123 memset(padded + gotn,
'0', 5);
125 mp_ptr back = alloc_limbs((
size_t)need + 2);
144 char* got = (
char*)
lmmp_alloc((
size_t)dlen + 8);
148 TEST_CHECK_MSG(memcmp(got, digits, (
size_t)refn) == 0,
"to_decimal vs to_str+chars");
156 for (
mp_size_t i = 0; i < gotn && i < ref_digits_len; ++i)
157 if (rd[(
size_t)i] != (
mp_byte_t)(got[i] -
'0')) {
166 for (
mp_size_t i = 0; i < refn; ++i) digit_vals[(
size_t)i] = (
mp_byte_t)(digits[i] -
'0');
168 mp_ptr want = alloc_limbs((
size_t)wlen + 2);
172 memcpy(padded, got, gotn);
173 memset(padded + gotn,
'0', 3);
176 mp_ptr back = alloc_limbs((
size_t)dneed + 2);
180 TEST_CHECK_MSG(memcmp(back, want, (
size_t)wantn * 8) == 0,
"from_decimal vs from_str");
191 u64 seed = 0xe3459cd6b789abeful;
192 int bases[] = {2, 8, 10, 16, 36, 62, 100, 256};
193 for (
size_t base_index = 0; base_index <
ARRAY_SIZE(bases); ++base_index) {
194 int base = bases[base_index];
195 const mp_size_t n_values[] = {1, 2, 5, 10, 20, 40};
196 for (
size_t n_index = 0; n_index <
ARRAY_SIZE(n_values); ++n_index) {
198 for (
int iter = 0; iter < 3; ++iter) {
200 random_limbs(x,
n, &seed);
208 mp_ptr back = alloc_limbs((
size_t)need + 2);
210 TEST_CHECK_MSG(mpn_eq(back, back_n, x,
n),
"string roundtrip equality");
215 bool dok = ref_digits_len == actual &&
216 memcmp(rd, str, (
size_t)actual) == 0;
221 mp_ptr hv = alloc_limbs((
size_t)need + 2);
223 TEST_CHECK_MSG(mpn_eq(hv, hn, x,
n),
"from_str value == Horner rebuild");
232 mp_ptr z = alloc_limbs(2);
238 mp_ptr back = alloc_limbs(2);
253 if (actual == expected_len)
254 TEST_CHECK_MSG(memcmp(str, expect, actual) == 0,
"known digit string match");
259 const mp_limb_t v0[] = {0},
v1[] = {1}, v10[] = {10}, v255[] = {255};
265 check_value(v255, 1, (
const mp_byte_t[]){1, 1, 1, 1, 1, 1, 1, 1}, 8, 2);
274 memset(wantF, 15,
sizeof(wantF));
279 u64 seed = 0xfeedfacecafebeeful;
280 const mp_size_t n_values[] = {1, 2, 3, 5, 17, 64, 100, 333};
281 for (
size_t n_index = 0; n_index <
ARRAY_SIZE(n_values); ++n_index) {
284 random_limbs(x,
n, &seed);
289 const u64 top_values[] = {1ull, 0xfull, 0x10ull, 0xffull};
290 for (
size_t top_index = 0; top_index <
ARRAY_SIZE(top_values); ++top_index) {
291 u64 top = top_values[top_index];
292 mp_ptr x = alloc_limbs(9);
293 random_limbs(x, 9, &seed);
304 mp_ptr dst = alloc_limbs(4);
317 u64 seed = 0xd1ce0dd1ce0dd1ceull;
319 const mp_size_t n_values[] = {1, 2, 3, 29, 30, 31, 44, 45, 60, 100, 137, 200, 300};
320 for (
size_t n_index = 0; n_index <
ARRAY_SIZE(n_values); ++n_index) {
323 random_limbs(x,
n, &seed);
328 for (
int rep = 0; rep < 3; ++rep) {
329 mp_ptr x = alloc_limbs(33);
330 random_limbs(x, 33, &seed);
335 const u64 top_values[] = {1ull, 0x10ull, 0xffull};
336 for (
size_t top_index = 0; top_index <
ARRAY_SIZE(top_values); ++top_index) {
337 u64 top = top_values[top_index];
338 mp_ptr x = alloc_limbs(41);
339 random_limbs(x, 41, &seed);
350 mp_ptr dst = alloc_limbs(4);
360TEST_CASE(
"str/decimal_powcache", decimal_pow_cache_lifecycle) {
361 u64 seed = 0x5eed5eed5eed5eedull;
362 mp_ptr big1 = alloc_limbs(300), big2 = alloc_limbs(150), small = alloc_limbs(35);
363 random_limbs(big1, 300, &seed);
364 random_limbs(big2, 150, &seed);
365 random_limbs(small, 35, &seed);
382 TEST_RUN(
"str/roundtrip", to_str_from_str_roundtrip);
383 TEST_RUN(
"str/known", known_values);
384 TEST_RUN(
"str/hex_spec", hex_specialized);
385 TEST_RUN(
"str/decimal_spec", decimal_specialized);
386 TEST_RUN(
"str/decimal_powcache", decimal_pow_cache_lifecycle);
#define lmmp_zero(dst, n)
void * lmmp_alloc(size_t size)
内存分配函数(调用lmmp_heap_alloc_fn)
const mp_limb_t * mp_srcptr
void lmmp_free(void *ptr)
内存释放函数(调用lmmp_heap_free_fn)
void lmmp_global_init(void)
全局初始化函数(线程局部的)
void lmmp_global_deinit(void)
全局释放函数(线程局部的)
mp_limb_t u64
Copyright (C) 2026 HJimmyK (Jericho Knox)
mp_limb_t lmmp_div_1_(mp_ptr dstq, mp_srcptr numa, mp_size_t na, mp_limb_t x)
单精度数除法
mp_size_t lmmp_to_hex_len_(mp_srcptr numa, mp_size_t na)
计算转换为十六进制字符串需要的缓冲区长度
mp_size_t lmmp_from_hex_len_(const char *src, mp_size_t len)
计算十六进制字符串转limb数组所需的 limb 缓冲区长度
mp_size_t lmmp_to_decimal_(char *dst, mp_srcptr numa, mp_size_t na)
limb数组转十进制字符串 [numa,na,B] to [dst,return value,10]
mp_size_t lmmp_from_decimal_(mp_ptr dst, const char *src, mp_size_t len)
十进制字符串转limb数组 [src,len,10] to [dst,return value,B]
mp_size_t lmmp_to_str_(mp_byte_t *dst, mp_srcptr numa, mp_size_t na, int base)
limb数组转字节数组操作 [numa,na,B] to [dst,return value,base]
mp_size_t lmmp_to_hex_(char *dst, mp_srcptr numa, mp_size_t na, bool upper)
limb数组转十六进制字符串 [numa,na,B] to [dst,return value,16]
void lmmp_dec_to_chars_(mp_byte_t *dst, mp_size_t n)
十进制数字字节原地转字符 [dst,n]: [0,9] -> ['0','9']
mp_size_t lmmp_from_str_(mp_ptr dst, const mp_byte_t *src, mp_size_t len, int base)
字节数组转limb数组操作 [src,len,base] to [dst,return value,B]
mp_size_t lmmp_to_str_len_(mp_srcptr numa, mp_size_t na, int base)
计算转换为字节数组,字节数组需要的缓冲区长度
mp_size_t lmmp_to_decimal_len_(mp_srcptr numa, mp_size_t na)
计算转换为十进制字符串需要的缓冲区长度
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
mp_size_t lmmp_from_decimal_len_(const char *src, mp_size_t len)
计算十进制字符串转limb数组所需的 limb 缓冲区长度
mp_size_t lmmp_from_hex_(mp_ptr dst, const char *src, mp_size_t len)
十六进制字符串转limb数组 [src,len,16] to [dst,return value,B]
mp_size_t lmmp_from_str_len_(const mp_byte_t *src, mp_size_t len, int base)
计算字节数组转limb数组所需的 limb 缓冲区长度
#define ARRAY_SIZE(a)
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define TEST_CHECK_MSG(cond, msg)
#define TEST_CASE(category, name)
#define TEST_CHECK_EQ(a, b)
#define TEST_RUN(category, name)
static int limb_bits_of(u64 x)
static mp_size_t ref_hex_string(char *out, mp_srcptr x, mp_size_t n, bool upper)
static mp_size_t ref_digits(mp_byte_t *out, mp_srcptr x, mp_size_t n, int base)
Copyright (C) 2026 HJimmyK (Jericho Knox)
static void check_hex_one(mp_srcptr x, mp_size_t n)
static mp_size_t ref_value(mp_ptr val, mp_size_t cap, const mp_byte_t *d, mp_size_t len, int base)
static void check_value(mp_srcptr x, mp_size_t n, const mp_byte_t *expect, mp_size_t expected_len, int base)
static void check_decimal_one(mp_srcptr x, mp_size_t n)