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

浏览该文件的源代码.

结构体

struct  lmmp_hgcd_matrix_t
 hgcd 变换矩阵 更多...

类型定义

typedef int8_t schar
typedef int8_t * scharp
typedef int32_t sint
typedef int32_t * sintp
typedef int64_t slong
typedef int64_t * slongp
typedef int16_t sshort
typedef int16_t * sshortp
typedef uint8_t uchar
 Copyright (C) 2026 HJimmyK (Jericho Knox)
typedef uint8_t * ucharp
typedef uint32_t uint
typedef uint32_t * uintp
typedef uint64_t ulong
typedef uint64_t * ulongp
typedef uint16_t ushort
typedef uint16_t * ushortp

函数

mp_size_t lmmp_2factorial_ (mp_ptr dst, mp_bitcnt_t bits, mp_size_t rn, uint n)
 计算 n!
mp_size_t lmmp_2factorial_size_ (uint n, mp_bitcnt_t *bits)
 计算 n!
mp_size_t lmmp_arith_seqprod_ (mp_ptr dst, mp_size_t rn, uint x, uint n, uint m)
 计算等差数列乘积 x(x+m)...(x+n*m)
mp_size_t lmmp_arith_seqprod_size_ (uint x, uint n, uint m)
 计算等差数列乘积 x(x+m)...(x+n*m)的 limb 缓冲区长度
void lmmp_binvert_ (mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t n)
 计算 [numa,na] 在 B^n 下的逆元
void lmmp_binvert_2_ (mp_ptr dst, mp_srcptr numa)
 计算 [numa,2] 在 B^2 下的逆元
void lmmp_binvert_3_ (mp_ptr dst, mp_srcptr numa)
 计算 [numa,3] 在 B^3 下的逆元
void lmmp_binvert_4_ (mp_ptr dst, mp_srcptr numa)
 计算 [numa,4] 在 B^4 下的逆元
void lmmp_binvert_n_dc_ (mp_ptr dst, mp_srcptr numa, mp_size_t n, mp_ptr tp)
 计算 [numa,n] 在 B^n 下的逆元
uint lmmp_binvert_uint_ (uint a)
 计算 a 在2^32下的逆元
ulong lmmp_binvert_ulong_ (ulong a)
 计算 a 在2^64下的逆元
void lmmp_binvert_unbalance_ (mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_size_t n, mp_ptr tp)
 计算 [numa,na] 在 B^n 下的逆元
void lmmp_binvert_unbalance_1_ (mp_ptr dst, mp_limb_t a, mp_size_t n)
 计算 a 在 B^n 下的逆元
void lmmp_binvert_unbalance_2_ (mp_ptr dst, mp_srcptr numa, mp_size_t n)
 计算 [numa,2] 在 B^n 下的逆元
void lmmp_cbrt_ (mp_ptr dsts, mp_ptr dstr, mp_srcptr numa, mp_size_t na, mp_size_t nf)
 计算 [numa,na] * B^(3*nf) 的立方根和余数
mp_limb_t lmmp_cbrt_3_ (mp_limb_t a0, mp_limb_t a1, mp_limb_t a2)
 计算算数立方根 floor(cbrt(a0+a1*B+a2*B^2))
void lmmp_cbrt_6_ (mp_ptr dst, mp_srcptr numa, mp_size_t na)
 计算算术立方根 floor(cbrt([numa,na]))
void lmmp_cbrt_6_fast_ (mp_ptr dst, mp_ptr numa, mp_ptr tp)
 计算算术立方根 [dst,2] = floor(cbrt([numa,6]))
ulong lmmp_cbrt_chebyshev_ (ulong n)
 计算算数立方根 floor(cbrt(n))
void lmmp_cbrt_divide_ (mp_ptr dst, mp_ptr numa, mp_size_t ns, mp_ptr tp, int calr)
 计算算术立方根 floor(cbrt([numa,3*ns]))
void lmmp_cbrt_newton_ (mp_ptr dsts, mp_srcptr numa, mp_size_t na, mp_size_t nf)
 计算近似立方根 [dsts,na/3+nf+1]=[floor|round](cbrt([numa,na]*B^(3*nf))), 输入须已归一化:na ≡ 0 (mod 3) 且顶 limb >= B/8
ulong lmmp_cbrt_ulong_ (ulong n)
 计算算数立方根 floor(cbrt(n))
void lmmp_divexact_ (mp_ptr dst, mp_srcptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn)
 精确除法([dst,nn]=[np,nn]/[dp,dn],且余数必须为0)
void lmmp_divexact_1_ (mp_ptr dst, mp_srcptr np, mp_size_t nn, mp_limb_t d, mp_limb_t dinv)
 精确除法([dst,nn]=[np,nn]/d,且余数必须为0)
void lmmp_divexact_2_ (mp_ptr dst, mp_srcptr np, mp_size_t nn, mp_srcptr dp, mp_srcptr dinv)
 精确除法([dst,nn]=[np,nn]/[dp,2],且余数必须为0)
void lmmp_divexact_basecase_ (mp_ptr dst, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn)
 精确除法([dst,nn-dn+1]=[np,nn]/[dp,dn],且余数必须为0),朴素算法
void lmmp_divexact_divide_ (mp_ptr dst, mp_srcptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn)
 精确除法([dst,nn]=[np,nn]/[dp,dn],且余数必须为0),分治算法
void lmmp_divexact_unbalance_ (mp_ptr dst, mp_srcptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_ptr dinv)
 精确除法([dst,nn]=[np,nn]/[dp,dn],且余数必须为0)
mp_size_t lmmp_factorial_ (mp_ptr dst, mp_bitcnt_t bits, mp_size_t rn, uint n)
 计算 n!
mp_size_t lmmp_factorial_size_ (uint n, mp_bitcnt_t *bits)
 计算 n!
mp_size_t lmmp_fibonacci2_ (mp_ptr dst, mp_ptr dst2, mp_size_t rn, ulong n)
 计算 Fibonacci 数对:[dst,rn] = F[n],[dst2,rn] = F[n-1]
mp_size_t lmmp_fibonacci_ (mp_ptr dst, mp_size_t rn, ulong n)
 计算 Fibonacci 数 [dst,rn] = F[n]
mp_size_t lmmp_fibonacci_size_ (ulong n)
 计算 Fibonacci 数 F[n](及 F[n-1])所需的 limb 缓冲区长度
mp_size_t lmmp_gcd_ (mp_ptr dst, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
 计算两个无符号整数的最大公约数(通用分发入口)
mp_limb_t lmmp_gcd_11_ (mp_limb_t u, mp_limb_t v)
 计算两个无符号整数的最大公约数
mp_limb_t lmmp_gcd_1_ (mp_srcptr up, mp_size_t un, mp_limb_t v)
 计算两个无符号整数的最大公约数
mp_size_t lmmp_gcd_22_ (mp_ptr dst, mp_srcptr up, mp_srcptr vp)
 计算两个无符号整数的最大公约数
mp_size_t lmmp_gcd_2_ (mp_ptr dst, mp_srcptr up, mp_size_t un, mp_srcptr vp)
 计算两个无符号整数的最大公约数
mp_size_t lmmp_gcd_hgcd_ (mp_ptr dst, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
 计算两个无符号整数的最大公约数(hgcd 分治,长输入优选)
mp_size_t lmmp_gcd_lehmer_ (mp_ptr dst, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
 计算两个无符号整数的最大公约数(Lehmer算法)
mp_size_t lmmp_gcdext_ (mp_ptr dstg, mp_ptr dsts, mp_ssize_t *sn, mp_ptr dstt, mp_ssize_t *tn, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
 扩展欧几里得(通用分发入口):g = gcd(u,v),s*u + t*v = g
ulong lmmp_gcdext_11_ (ulong u, ulong v, slong *s, slong *t)
 扩展欧几里得(双 limb 标量):g = gcd(u,v),s*u + t*v = g
mp_size_t lmmp_gcdext_1_ (mp_ptr dstg, mp_ptr dsts, mp_ssize_t *sn, mp_ptr dstt, mp_ssize_t *tn, mp_srcptr up, mp_size_t un, ulong v)
 扩展欧几里得(任意长度对单 limb):g = gcd([up,un],v),s*u + t*v = g
mp_size_t lmmp_gcdext_2_ (mp_ptr dstg, mp_ptr dsts, mp_ssize_t *sn, mp_ptr dstt, mp_ssize_t *tn, mp_srcptr up, mp_size_t un, mp_srcptr vp)
 扩展欧几里得(任意长度对双 limb):g = gcd([up,un],[vp,2]),s*u + t*v = g
mp_size_t lmmp_gcdext_hgcd_ (mp_ptr dstg, mp_ptr dsts, mp_ssize_t *sn, mp_ptr dstt, mp_ssize_t *tn, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
 扩展欧几里得(hgcd 分治,长输入优选):g = gcd(u,v),s*u + t*v = g
mp_size_t lmmp_gcdext_lehmer_ (mp_ptr dstg, mp_ptr dsts, mp_ssize_t *sn, mp_ptr dstt, mp_ssize_t *tn, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
 扩展欧几里得(Lehmer 算法):g = gcd(u,v),s*u + t*v = g
mp_size_t lmmp_hgcd_ (lmmp_hgcd_matrix_t *M, mp_ptr ap, mp_ptr bp, mp_size_t n)
 半扩展欧几里得:将数对原地归约至约一半规模,并累积变换矩阵
void lmmp_hgcd_matrix_free_ (lmmp_hgcd_matrix_t *M)
 释放 hgcd 变换矩阵的元素缓冲
void lmmp_hgcd_matrix_init_ (lmmp_hgcd_matrix_t *M, mp_size_t alloc)
 初始化 hgcd 变换矩阵为单位矩阵(堆分配元素缓冲)
mp_size_t lmmp_hyperfac_ (mp_ptr dst, mp_bitcnt_t bits, mp_size_t rn, ushort n)
 计算hyper阶乘(k^k累乘至n)
mp_size_t lmmp_hyperfac_size_ (ushort n, mp_bitcnt_t *bits)
 计算hyper阶乘的 limb 缓冲区长度
void lmmp_invcbrt_newton_ (mp_ptr dstis, mp_size_t ns, mp_srcptr numa, mp_size_t na)
 计算逆立方根的定点下近似:记 I=floor(cbrt(B^(3*ns+na)/[numa,na])), 则 [dstis,ns+1] 满足 I-1 <= [dstis,ns+1] <= I,且 dstis[ns]>=1
void lmmp_invsqrt_newton_ (mp_ptr dstis, mp_size_t ns, mp_srcptr numa, mp_size_t na)
 计算逆平方根的定点下近似:记 I=floor(sqrt(B^(2*ns+na)/[numa,na])), 则 [dstis,ns+1] 满足 I-1 <= [dstis,ns+1] <= I,且 dstis[ns]=1
int lmmp_is_prime_2_ (mp_limb_t lo, mp_limb_t hi)
 判断 128 位素数
int lmmp_is_prime_2_notrial_ (mp_limb_t lo, mp_limb_t hi)
 判断 128 位素数(无试除法)
int lmmp_is_prime_n_ (mp_srcptr np, mp_size_t nn, int strength)
 大整数素性检验(强度分档,大于 128 位)
int lmmp_is_prime_n_notrial_ (mp_srcptr np, mp_size_t nn, int strength)
 大整数素性检验(无试除法,强度分档,大于 128 位)
bool lmmp_is_prime_uint_ (uint n)
 判断素数
bool lmmp_is_prime_ulong_ (ulong n)
 判断素数
bool lmmp_is_prime_ulong_notrial_ (ulong n)
 判断素数(无试除法,单 limb 档)
int lmmp_is_prothprime_ (uint k, mp_size_t n)
 Proth 数 k*2^n+1 的素性判定(普罗斯定理)
int lmmp_is_strong_lucas_ (mp_srcptr np, mp_size_t nn)
 强 Lucas-Selfridge 测试(大于 128 位)
mp_limb_t lmmp_mod_2p48sub1_ (mp_srcptr p, mp_size_t n)
 计算 [p,n] % 2^48-1
mp_size_t lmmp_modinv_ (mp_ptr dst, mp_srcptr up, mp_size_t un, mp_srcptr mp, mp_size_t mn)
 模逆元(任意长度):求 [up,un]^{-1} mod [mp,mn]
ulong lmmp_modinv_ulong_ (ulong u, ulong m)
 模逆元(单 limb):求 u^{-1} mod m
ulong lmmp_mulmod_ulong_ (ulong a, ulong b, ulong mod, ulongp q)
 计算两个无符号整数的乘积,对mod取模,商放入 q 中
mp_size_t lmmp_multinomial_ (mp_ptr dst, mp_size_t rn, uint n, const uintp r, uint m)
 计算多项式系数
mp_size_t lmmp_multinomial_size_ (const uintp r, uint m, ulong *n)
 计算多项式系数的 limb 缓冲区长度
mp_size_t lmmp_nCr_ (mp_ptr dst, mp_bitcnt_t bits, mp_size_t rn, uint n, uint r)
 计算 nCr 组合数 ( nCr = n!
mp_size_t lmmp_nCr_size_ (uint n, uint r, mp_bitcnt_t *bits)
 计算 nCr 组合数的 limb 缓冲区长度
ulong lmmp_next_prime_ulong_ (ulong n)
 大于n的下一个素数
mp_size_t lmmp_nPr_ (mp_ptr dst, mp_bitcnt_t bits, mp_size_t rn, ulong n, ulong r)
 计算 nPr 排列数 ( nPr = n!
mp_size_t lmmp_nPr_size_ (ulong n, ulong r, mp_bitcnt_t *bits)
 计算 nPr 排列数的 limb 缓冲区长度
void lmmp_nthroot_ (mp_ptr dsts, mp_ptr dstr, mp_srcptr numa, mp_size_t na, ulong root, mp_ptr tp)
 计算算术根 [dsts,nr] = floor([numa,na]^(1/root))(任意 na/任意顶 limb)
mp_size_t lmmp_nthroot_size_ (mp_size_t na, ulong root)
 计算 lmmp_nthroot_ 所需的 tp 缓冲区长度(任意长度输入入口)
ulong lmmp_nthroot_ulong_ (ulong n, ulong root)
 计算 floor(n^(1/root))
mp_size_t lmmp_odd_factorial_uint_ (mp_ptr dst, mp_size_t rn, uint n)
 计算 n!
mp_size_t lmmp_odd_nCr_uint_ (mp_ptr dst, mp_size_t rn, uint n, uint r)
 计算 nCr 组合数的奇数部分
mp_size_t lmmp_odd_nCr_ushort_ (mp_ptr dst, mp_size_t rn, uint n, uint r)
 计算 nCr 组合数的奇数部分
mp_size_t lmmp_odd_nPr_uint_ (mp_ptr dst, mp_size_t rn, ulong n, ulong r)
 计算 nPr 排列数的奇数部分
mp_size_t lmmp_odd_nPr_ulong_ (mp_ptr dst, mp_size_t rn, ulong n, ulong r)
 计算 nPr 排列数的奇数部分
mp_size_t lmmp_odd_nPr_ushort_ (mp_ptr dst, mp_size_t rn, ulong n, ulong r)
 计算 nPr 排列数的奇数部分
bool lmmp_perfsqr_ (mp_srcptr p, mp_size_t n)
 判断[p,n]是否为完全平方数
bool lmmp_perfsqr_filter_ (mp_srcptr p, mp_size_t n)
 非完全平方数过滤器
bool lmmp_perfsqr_filter_1_ (mp_limb_t p)
 非完全平方数过滤器
mp_size_t lmmp_pow_ (mp_ptr dst, mp_size_t rn, mp_srcptr base, mp_size_t n, ulong exp)
 计算大整数幂 [dst,rn] = [base,n] ^ exp
mp_size_t lmmp_pow_1_ (mp_ptr dst, mp_size_t rn, mp_limb_t base, ulong exp)
 计算幂次方 [dst,rn] = [base,1] ^ exp
mp_size_t lmmp_pow_1_size_ (mp_limb_t base, ulong exp)
 计算幂次方需要的limb缓冲区长度 base ^ exp
mp_size_t lmmp_pow_basecase_ (mp_ptr dst, mp_size_t rn, mp_srcptr base, mp_size_t n, ulong exp)
 计算奇数次幂算法 [dst,rn] = [base,n] ^ exp
mp_size_t lmmp_pow_size_ (mp_srcptr base, mp_size_t n, ulong exp)
 计算幂次方需要的limb缓冲区长度 [base,n] ^ exp
mp_size_t lmmp_pow_win2_ (mp_ptr dst, mp_size_t rn, mp_srcptr base, mp_size_t n, ulong exp)
 计算幂次方2比特窗口快速幂算法 [dst,rn] = [base,n] ^ exp
void lmmp_powlo_ (mp_ptr dst, mp_srcptr bp, mp_size_t n, mp_srcptr ep, mp_size_t en)
 计算 [bp,n]^[ep,en] mod B^n,并将结果写入 [dst,n]
void lmmp_powlo_1_ (mp_ptr dst, mp_srcptr bp, mp_srcptr ep, mp_size_t en)
 计算 [bp,1]^[ep,en] mod B,并将结果写入 [dst,1](lmmp_powlo_ 的 1 limb 特化)
void lmmp_powlo_2_ (mp_ptr dst, mp_srcptr bp, mp_srcptr ep, mp_size_t en)
 计算 [bp,2]^[ep,en] mod B^2,并将结果写入 [dst,2](lmmp_powlo_ 的 2 limb 特化)
void lmmp_powmod_ (mp_ptr dst, mp_srcptr bp, mp_srcptr ep, mp_size_t en, mp_srcptr mp, mp_size_t n)
 计算任意模数模幂 [dst,n] = [bp,n]^[ep,en] % [mp,n]
void lmmp_powmod_1_ (mp_ptr dst, mp_srcptr bp, mp_srcptr ep, mp_size_t en, mp_limb_t mod)
 计算奇模数模幂 [dst,1] = [bp,1]^[ep,en] % mod
void lmmp_powmod_2_ (mp_ptr dst, mp_srcptr bp, mp_srcptr ep, mp_size_t en, mp_srcptr mod)
 计算奇模数模幂 [dst,2] = [bp,2]^[ep,en] % [mod,2]
void lmmp_powmod_odd_ (mp_ptr dst, mp_srcptr bp, mp_srcptr ep, mp_size_t en, mp_srcptr mp, mp_size_t n)
 计算奇模数模幂 [dst,n] = [bp,n]^[ep,en] % [mp,n]
uint lmmp_powmod_uint_odd_ (uint base, ulong exp, uint mod)
 计算 base^exp 对 mod 取模
ulong lmmp_powmod_ulong_odd_ (ulong base, ulong exp, ulong mod)
 计算 base^exp 对 mod 取模
ulong lmmp_prev_prime_ulong_ (ulong n)
 小于等于n的上一个素数
mp_size_t lmmp_primefac_ (mp_ptr dst, mp_size_t rn, uint n)
 计算质数阶乘(不超过n的质数累乘)
mp_size_t lmmp_primefac_size_ (uint n)
 计算质数阶乘的 limb 缓冲区长度
mp_limb_t lmmp_redc_ (mp_ptr dst, mp_srcptr tp, mp_srcptr ninv, mp_srcptr mp, mp_size_t n)
 Montgomery 归约(REDC):计算 ([tp,2n] + q*[mp,n]) / B^n,其中 q = [tp,n] * [ninv,n] mod B^n,即结果为 [tp,2n] * B^(-n) % [mp,n]
mp_size_t lmmp_remove_ (mp_ptr np, mp_size_t *nn, mp_srcptr dp, mp_size_t dn)
 除去 [np,nn] 中的 [dp,dn] 的因子
void lmmp_sqrt_ (mp_ptr dsts, mp_ptr dstr, mp_srcptr numa, mp_size_t na, mp_size_t nf)
 计算 [numa,na] * B^(2*nf) 的平方根和余数
mp_limb_t lmmp_sqrt_1_ (mp_ptr dstr, mp_limb_t x)
 计算算术平方根 floor(sqrt(x))
mp_limb_t lmmp_sqrt_2_ (mp_ptr dstr, mp_srcptr numa)
 计算算术平方根 floor(sqrt([numa,2]))
void lmmp_sqrt_3_ (mp_ptr dsts, mp_ptr dstr, mp_srcptr numa)
 计算算术平方根 floor(sqrt([numa,3]))
void lmmp_sqrt_4_ (mp_ptr dsts, mp_ptr dstr, mp_srcptr numa)
 计算算术平方根 floor(sqrt([numa,4]))
void lmmp_sqrt_divide_ (mp_ptr dst, mp_ptr numa, mp_size_t ns, mp_ptr tp, int calr)
 计算算术平方根 floor(sqrt([numa,2*ns]))
void lmmp_sqrt_newton_ (mp_ptr dsts, mp_srcptr numa, mp_size_t na, mp_size_t nf)
 计算近似平方根 [dsts,nf+na/2+1]=[floor|round](sqrt([numa,na]*B^(2*nf)))
ulong lmmp_sqrt_ulong_ (ulong a)
 计算算术平方根 floor(sqrt(a))
mp_size_t lmmp_superfac_ (mp_ptr dst, mp_bitcnt_t bits, mp_size_t rn, ushort n)
 计算super阶乘(k!
mp_size_t lmmp_superfac_size_ (ushort n, mp_bitcnt_t *bits)
 计算super阶乘的 limb 缓冲区长度
mp_size_t lmmp_u16_pow_1_ (mp_ptr dst, mp_size_t rn, ulong base, ulong exp)
 计算幂次方 [dst,rn] = [base,1] ^ exp
mp_size_t lmmp_u32_pow_1_ (mp_ptr dst, mp_size_t rn, ulong base, ulong exp)
 计算幂次方 [dst,rn] = [base,1] ^ exp
mp_size_t lmmp_u4_pow_1_ (mp_ptr dst, mp_size_t rn, ulong base, ulong exp)
 计算幂次方 [dst,rn] = [base,1] ^ exp
mp_size_t lmmp_u64_pow_1_ (mp_ptr dst, mp_size_t rn, ulong base, ulong exp)
 计算幂次方 [dst,rn] = [base,1] ^ exp
mp_size_t lmmp_u8_pow_1_ (mp_ptr dst, mp_size_t rn, ulong base, ulong exp)
 计算幂次方 [dst,rn] = [base,1] ^ exp

结构体说明

◆ lmmp_hgcd_matrix_t

struct lmmp_hgcd_matrix_t

hgcd 变换矩阵

注解
/ a \ / m00 m01 \ / a' \ | | = | | * | | \ b / \ m10 m11 / \ b' / 其中 (a;b) 为 hgcd 入口数对,(a';b') 为归约后数对。矩阵元素均非负, det(M) = ±1,元素值不超过入口较大分量的规模。 每个元素显式存储真实长度 n[i][j](归一化,顶 limb 非零; n[i][j]==0 表示零元素),不做零填充:元素缓冲 [0, n[i][j]) 之外 的内容无效,一切访问以长度为准。长度由库内计算过程显式维护 (乘法进位/最高位),不做前导零扫描。 各元素长度 <= alloc。

在文件 numth.h 第 277 行定义.

lmmp_hgcd_matrix_t 的协作图:
成员变量
mp_size_t alloc
mp_ptr m[2][2]
mp_size_t n[2][2]

类型定义说明

◆ schar

typedef int8_t schar

在文件 numth.h 第 35 行定义.

◆ scharp

typedef int8_t* scharp

在文件 numth.h 第 43 行定义.

◆ sint

typedef int32_t sint

在文件 numth.h 第 40 行定义.

◆ sintp

typedef int32_t* sintp

在文件 numth.h 第 47 行定义.

◆ slong

typedef int64_t slong

在文件 numth.h 第 41 行定义.

◆ slongp

typedef int64_t* slongp

在文件 numth.h 第 49 行定义.

◆ sshort

typedef int16_t sshort

在文件 numth.h 第 37 行定义.

◆ sshortp

typedef int16_t* sshortp

在文件 numth.h 第 45 行定义.

◆ uchar

typedef uint8_t uchar

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

在文件 numth.h 第 34 行定义.

◆ ucharp

typedef uint8_t* ucharp

在文件 numth.h 第 42 行定义.

◆ uint

typedef uint32_t uint

在文件 numth.h 第 38 行定义.

◆ uintp

typedef uint32_t* uintp

在文件 numth.h 第 46 行定义.

◆ ulong

typedef uint64_t ulong

在文件 numth.h 第 39 行定义.

◆ ulongp

typedef uint64_t* ulongp

在文件 numth.h 第 48 行定义.

◆ ushort

typedef uint16_t ushort

在文件 numth.h 第 36 行定义.

◆ ushortp

typedef uint16_t* ushortp

在文件 numth.h 第 44 行定义.

函数说明

◆ lmmp_2factorial_()

mp_size_t lmmp_2factorial_ ( mp_ptr dst,
mp_bitcnt_t bits,
mp_size_t rn,
uint n )

计算 n!

! 双阶乘

参数
dst结果指针
bitsn!! 的2的因子数
rn结果指针的 limb 长度
n双阶乘的阶数
警告
dst!=NULL, rn>0
注解
0的双阶乘为1,n为偶数时,n!!=2*4*...*n,n为奇数时,n!!=1*3*...*n
返回
返回 dst 的实际 limb 长度

引用了 lmmp_2factorial_(), LMMP_API , 以及 n.

被这些函数引用 lmmp_2factorial_(), lmmp_2factorial_() , 以及 TEST_CASE().

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

◆ lmmp_2factorial_size_()

mp_size_t lmmp_2factorial_size_ ( uint n,
mp_bitcnt_t * bits )

计算 n!

! 双阶乘的 limb 缓冲区长度

参数
n双阶乘的阶数
bits被修改为 n!! 的2的因子数
警告
bits!=NULL
返回
n!! 双阶乘的 limb 缓冲区长度

引用了 lmmp_2factorial_size_(), LMMP_API , 以及 n.

被这些函数引用 lmmp_2factorial_size_(), lmmp_2factorial_size_() , 以及 TEST_CASE().

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

◆ lmmp_arith_seqprod_()

mp_size_t lmmp_arith_seqprod_ ( mp_ptr dst,
mp_size_t rn,
uint x,
uint n,
uint m )

计算等差数列乘积 x(x+m)...(x+n*m)

参数
dst结果指针
rn结果指针的 limb 长度
x首项
n等差数列共n+1项
m公差(大于1)
警告
x>0, m>1, n>0, dst!=NULL, rn>0, x+n*m<=0xffffffff
返回
结果的实际的 limb 缓冲区长度

引用了 LMMP_API, lmmp_arith_seqprod_() , 以及 n.

被这些函数引用 lmmp_arith_seqprod_(), lmmp_arith_seqprod_() , 以及 TEST_CASE().

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

◆ lmmp_arith_seqprod_size_()

mp_size_t lmmp_arith_seqprod_size_ ( uint x,
uint n,
uint m )

计算等差数列乘积 x(x+m)...(x+n*m)的 limb 缓冲区长度

Copyright (C) 2026 HJimmyK (Jericho Knox)

参数
x首项
n等差数列共n+1项
m公差
警告
x>0, m>1, n>0, x+n*m<=0xffffffff
返回
等差数列乘积的 limb 缓冲区长度(比实际长度多 1-2 个 limb)

计算等差数列乘积 x(x+m)...(x+n*m)的 limb 缓冲区长度

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

在文件 arith_seqprod.c 第 33 行定义.

33 {
34 lmmp_param_assert(x > 0);
36 lmmp_param_assert(m > 1);
37 /*
38 P = x(x+m)...(x+nm) = m^(n+1) * gamma(x/m+n+1)/gamma(x/m)
39 log2(P) = [(n+1)ln(m) + lgamma(x/m+n+1) - lgamma(x/m)] / ln2
40 由 x+n*m <= 2^32-1 的约束,lgamma参数不超过2^31,估计误差远小于1bit。
41 位数 = floor(log2(P))+1,故取floor+1。
42 */
43 const double ln2 = 0.69314718055994531;
44 double a = (double)x / (double)m;
45 double lp = ((double)(n + 1) * log((double)m) + lgamma(a + (double)(n + 1)) - lgamma(a)) / ln2;
46 mp_size_t rn1 = (((uint64_t)floor(lp) + 1) + LIMB_BITS - 1) / LIMB_BITS + 2;
47 // 共有n+1个数,每个数的位数最多为uint,一个limb最多可以容纳两个uint乘积
48 // 奇部积至多 ceil((n+1)/2) limb,shl 进位无条件写 dst[shw+bn] 需再留 1 limb
49 mp_size_t rn2 = (n + 1) / 2 + 2;
50 return LMMP_MIN(rn1, rn2);
51}
uint64_t mp_size_t
定义 lmmp.h:93
#define LMMP_MIN(l, o)
返回两个数中的较小值
定义 lmmp.h:450
#define LIMB_BITS
定义 lmmp.h:102
#define lmmp_param_assert(x)
定义 lmmp.h:509
#define n

引用了 LIMB_BITS, lmmp_arith_seqprod_size_(), LMMP_MIN, lmmp_param_assert , 以及 n.

被这些函数引用 lmmp_arith_seqprod_size_(), lmmp_multinomial_() , 以及 TEST_CASE().

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

◆ lmmp_binvert_()

void lmmp_binvert_ ( mp_ptr dst,
mp_srcptr numa,
mp_size_t na,
mp_size_t n )

计算 [numa,na] 在 B^n 下的逆元

参数
dst结果指针(长度为 n 个limb)
numa待求逆元指针(长度为 na 个limb)
na待求逆元的 limb 长度
n结果的 limb 长度
警告
n>=na>0, numa!=NULL, dst!=NULL, numa[0]%2==1, sep(dst,numa)

引用了 LMMP_API, lmmp_binvert_(), lmmp_divexact_1_() , 以及 n.

被这些函数引用 lmmp_binvert_(), lmmp_binvert_(), lmmp_mont_init_(), lmmp_powmod_(), TEST_CASE(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_binvert_2_()

void lmmp_binvert_2_ ( mp_ptr dst,
mp_srcptr numa )

计算 [numa,2] 在 B^2 下的逆元

参数
numa待求逆元指针(长度为 2 个limb)
dst结果指针(长度为 2 个limb)
警告
numa!=NULL, dst!=NULL, numa[0]%2==1, eqsep(dst,numa)

在文件 binvert_1.c 第 63 行定义.

63 {
64 lmmp_param_assert(dst != NULL && numa != NULL);
65 lmmp_param_assert(numa[0] % 2 == 1);
66 mp_limb_t k, t;
67 mp_limb_t a1 = numa[1];
68 mp_limb_t a0 = numa[0];
70 mp_limb_t z;
71 /*
72 xn * a0 == 1 + k * B
73 yn := xn * (2 - a * xn) mod B^2
74 := xn * (2 - a0 * xn - a1 * xn * B) mod B^2
75 := xn * (2 - 1 - k*B - a1 * xn * B) mod B^2
76 := xn * (1 - k*B - a1 * xn * B) mod B^2
77 := (xn - xn*k * B - a1 * xn^2 * B) mod B^2
78 */
79 _umul64to128_(a0, xn, &t, &k);
80 z = xn * k;
81 z += a1 * xn * xn;
82 dst[0] = xn;
83 dst[1] = -z;
84}
#define k
#define xn
uint64_t mp_limb_t
定义 lmmp.h:92
static void _umul64to128_(uint64_t a, uint64_t b, uint64_t *low, uint64_t *high)
#define a0
#define a1
#define t
ulong lmmp_binvert_ulong_(ulong a)
计算 a 在2^64下的逆元

引用了 _umul64to128_(), a0, a1, k, lmmp_binvert_2_(), lmmp_binvert_ulong_(), lmmp_param_assert, t , 以及 xn.

被这些函数引用 lmmp_binvert_2_(), lmmp_binvert_3_(), lmmp_binvert_4_(), lmmp_binvert_n_dc_(), lmmp_binvert_unbalance_2_(), lmmp_divexact_(), lmmp_powmod_2_(), mont2_preinv(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_binvert_3_()

void lmmp_binvert_3_ ( mp_ptr dst,
mp_srcptr numa )

计算 [numa,3] 在 B^3 下的逆元

参数
numa待求逆元指针(长度为 3 个limb)
dst结果指针(长度为 3 个limb)
警告
numa!=NULL, dst!=NULL, numa[0]%2==1, sep(dst,numa)

引用了 LMMP_API , 以及 lmmp_binvert_3_().

被这些函数引用 lmmp_binvert_3_(), lmmp_binvert_3_(), lmmp_binvert_n_dc_() , 以及 TEST_CASE().

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

◆ lmmp_binvert_4_()

void lmmp_binvert_4_ ( mp_ptr dst,
mp_srcptr numa )

计算 [numa,4] 在 B^4 下的逆元

参数
numa待求逆元指针(长度为 4 个limb)
dst结果指针(长度为 4 个limb)
警告
numa!=NULL, dst!=NULL, numa[0]%2==1, sep(dst,numa)

引用了 LMMP_API , 以及 lmmp_binvert_4_().

被这些函数引用 lmmp_binvert_4_(), lmmp_binvert_4_(), lmmp_binvert_n_dc_() , 以及 TEST_CASE().

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

◆ lmmp_binvert_n_dc_()

void lmmp_binvert_n_dc_ ( mp_ptr dst,
mp_srcptr numa,
mp_size_t n,
mp_ptr tp )

计算 [numa,n] 在 B^n 下的逆元

参数
numa待求逆元指针(长度为 n 个limb)
dst结果指针(长度为 n 个limb)
n结果的 limb 长度
tp临时工作区指针(长度为 5*(n+1)/2 个limb)
警告
numa!=NULL, dst!=NULL, numa[0]%2==1, sep(dst,numa,tp)

引用了 LMMP_API, lmmp_binvert_n_dc_(), n , 以及 tp.

被这些函数引用 lmmp_binvert_(), lmmp_binvert_n_dc_(), lmmp_binvert_n_dc_(), lmmp_binvert_unbalance_(), lmmp_divexact_divide_(), lmmp_divexact_unbalance_() , 以及 TEST_CASE().

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

◆ lmmp_binvert_uint_()

uint lmmp_binvert_uint_ ( uint a)

计算 a 在2^32下的逆元

参数
a待求逆元
警告
a%2==1
返回
逆元

在文件 binvert_1.c 第 37 行定义.

37 {
38 lmmp_param_assert(a % 2 == 1);
39 uint r, y;
40
41 r = binv_tab[(a / 2) & 0x7F]; /* 8 bits */
42 y = 1 - a * r;
43 r = r * (1 + y); /* 16 bits */
44 y *= y;
45 r = r * (1 + y); /* 32 bits */
46 return r;
47}
static const uchar binv_tab[128]
Copyright (C) 2026 HJimmyK (Jericho Knox)
uint32_t uint
定义 numth.h:38

引用了 binv_tab, lmmp_binvert_uint_() , 以及 lmmp_param_assert.

被这些函数引用 lmmp_binvert_uint_() , 以及 TEST_CASE().

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

◆ lmmp_binvert_ulong_()

ulong lmmp_binvert_ulong_ ( ulong a)

计算 a 在2^64下的逆元

参数
a待求逆元
警告
a%2==1
返回
逆元

在文件 binvert_1.c 第 49 行定义.

49 {
50 lmmp_param_assert(a % 2 == 1);
51 ulong r, y;
52
53 r = binv_tab[(a / 2) & 0x7F]; /* 8 bits */
54 y = 1 - a * r;
55 r = r * (1 + y); /* 16 bits */
56 y *= y;
57 r = r * (1 + y); /* 32 bits */
58 y *= y;
59 r = r * (1 + y); /* 64 bits */
60 return r;
61}
uint64_t ulong
定义 numth.h:39

引用了 binv_tab, lmmp_binvert_ulong_() , 以及 lmmp_param_assert.

被这些函数引用 lmmp_binvert_2_(), lmmp_binvert_n_dc_(), lmmp_binvert_ulong_(), lmmp_binvert_unbalance_1_(), lmmp_divexact_(), lmmp_divexact_basecase_(), lmmp_is_prime_ulong_notrial_(), lmmp_mont_init_(), lmmp_powmod_1_(), lmmp_powmod_ulong_odd_(), TEST_CASE(), TEST_CASE() , 以及 trialdiv_init_chunk_().

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

◆ lmmp_binvert_unbalance_()

void lmmp_binvert_unbalance_ ( mp_ptr dst,
mp_srcptr numa,
mp_size_t na,
mp_size_t n,
mp_ptr tp )

计算 [numa,na] 在 B^n 下的逆元

参数
dst结果指针(长度为 n 个limb)
numa待求逆元指针(长度为 na 个limb)
na待求逆元的 limb 长度
n结果的 limb 长度
tp临时工作区指针(长度为 (9*na+5)/2 个limb)
警告
numa[0]%2==1, n>na, dst!=NULL, numa!=NULL, tp!=NULL, sep(dst,numa,tp)

引用了 LMMP_API, lmmp_binvert_unbalance_(), n , 以及 tp.

被这些函数引用 lmmp_binvert_(), lmmp_binvert_unbalance_(), lmmp_binvert_unbalance_() , 以及 TEST_CASE().

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

◆ lmmp_binvert_unbalance_1_()

void lmmp_binvert_unbalance_1_ ( mp_ptr dst,
mp_limb_t a,
mp_size_t n )

计算 a 在 B^n 下的逆元

参数
dst结果指针(长度为 n 个limb)
a待求逆元
n结果的 limb 长度
警告
a%2==1, n>1, dst!=NULL

引用了 LMMP_API, lmmp_binvert_unbalance_1_() , 以及 n.

被这些函数引用 lmmp_binvert_(), lmmp_binvert_unbalance_1_(), lmmp_binvert_unbalance_1_() , 以及 TEST_CASE().

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

◆ lmmp_binvert_unbalance_2_()

void lmmp_binvert_unbalance_2_ ( mp_ptr dst,
mp_srcptr numa,
mp_size_t n )

计算 [numa,2] 在 B^n 下的逆元

参数
dst结果指针(长度为 n 个limb)
numa待求逆元指针(长度为 2 个limb)
n结果的 limb 长度
警告
numa[0]%2==1, n>2, dst!=NULL, numa!=NULL, sep(dst,numa)

引用了 LMMP_API, lmmp_binvert_unbalance_2_() , 以及 n.

被这些函数引用 lmmp_binvert_(), lmmp_binvert_unbalance_2_(), lmmp_binvert_unbalance_2_() , 以及 TEST_CASE().

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

◆ lmmp_cbrt_()

void lmmp_cbrt_ ( mp_ptr dsts,
mp_ptr dstr,
mp_srcptr numa,
mp_size_t na,
mp_size_t nf )

计算 [numa,na] * B^(3*nf) 的立方根和余数

参数
dsts立方根结果输出指针(缓冲区长度至少 nf+na/3+3 个limb)
dstr余数结果输出指针(缓冲区长度至少 2*(nf+na/3)+3 个limb,NULL 表示不计算余数)
numa源操作数指针(长度为 na 个limb)
na操作数的 limb 长度
nf精度因子
警告
na>0, numa[na-1]!=0, eqsep(dsts,numa), eqsep(dstr,numa)
注解
if (dstr != NULL) { [dsts],[dstr] = cbrtrem([numa,na]*B^(3*nf)),即精确 floor 立方根 与余数 [numa,na]*B^(3*nf) - [dsts]^3(长度 2*ns+1,ns 为根长) } else { if (nf == 0) { [dsts] = floor(cbrt([numa,na])) } else { [dsts] = [floor|round](cbrt([numa,na]*B^(3*nf))) } }
注意
如你需要精确的floor(cbrt(x))语义,请确保nf==0或传入dstr

在文件 cbrt.c 第 718 行定义.

718 {
719 lmmp_debug_assert(na > 0);
720 lmmp_debug_assert(numa[na - 1] > 0);
721 mp_size_t nl = na + 3 * nf;
722
723 if (nl <= 6) {
724 // 小输入:任意归一化均可由基例函数族直接处理
725 mp_limb_t xb[6] = {0, 0, 0, 0, 0, 0}, r[2] = {0, 0};
726 for (mp_size_t i = 0; i < na; ++i) xb[3 * nf + i] = numa[i];
727
728 if (nl <= 2) {
729 r[0] = nl == 1 ? lmmp_cbrt_ulong_(xb[0]) : lmmp_cbrt_3_(xb[0], xb[1], 0);
730 } else if (nl == 3) {
731 r[0] = lmmp_cbrt_3_(xb[0], xb[1], xb[2]);
732 } else {
733 lmmp_cbrt_6_(r, xb, nl);
734 }
735 mp_size_t ns = (nl + 2) / 3;
736 dsts[0] = r[0];
737 if (ns > 1) dsts[1] = r[1];
738
739 if (dstr) {
740 // [dstr,2*ns+1] = X - r^3:立方由基例原语直接给出,
741 // rem < 3r^2+3r+1 < B^(2*ns+1),低段直接减无借位
742 mp_limb_t t[10];
743 if (ns == 1) {
744 lmmp_cube_3_(t, r[0]);
745 lmmp_sub_n_(dstr, xb, t, 3);
746 } else {
747 lmmp_cube_6_(t, r);
748 lmmp_sub_n_(dstr, xb, t, 5);
749 }
750 }
751 return;
752 }
753
754 /*
755 与 lmmp_sqrt_ 的分发同构:大 nf 无余数走 lmmp_cbrt_newton_ 的
756 [floor|round] 近似;其余(含全部 dstr != NULL 与精确 floor 语义)
757 统一走 knorm 归一化 + lmmp_cbrt_divide_ 精确求根,>>t 与 div_1(k)
758 的 floor 复合精确还原,无需任何修正循环。
759
760 cbrt_newton_ 为输入契约版(na ≡ 0 (mod 3),顶 limb >= B/8),
761 归一化与还原在本分发处完成:snorm 纯移位归一化(与 knorm 的 k=1
762 移位路径共用 shapply,B/8 即满足迭代收敛)+ 契约调用 + 结果 >>t
763 的 floor 复合还原。na2 = 3*ceil(na/3) 使 na2/3+nf+1 恰等于
764 (na+3nf+2)/3+1,>>t 后的写入长度与语义和内部归一化旧版一致。
765 */
766 if (!dstr && nf >= CBRT_INVNEWTON_K_THRESHOLD * na && nf >= CBRT_INVNEWTON_NF_MIN) {
767 TEMP_DECL;
768 mp_ptr a2 = TALLOC_TYPE(na + 3, mp_limb_t);
769 mp_size_t na2;
770 mp_size_t t = lmmp_cbrt_snorm_(numa, na, a2, &na2);
771 lmmp_debug_assert(na2 / 3 + nf + 1 == (na + 3 * nf + 2) / 3 + 1);
772 lmmp_cbrt_newton_(dsts, a2, na2, nf);
773 if (t)
774 lmmp_shr_(dsts, dsts, na2 / 3 + nf + 1, t);
775 TEMP_FREE;
776 return;
777 }
778
779 TEMP_DECL;
780 mp_ptr a2 = TALLOC_TYPE(na + 5, mp_limb_t);
781 mp_size_t na2;
782 mp_limb_t k;
783 mp_size_t t = lmmp_cbrt_knorm_(numa, na, a2, &na2, &k);
784
785 mp_size_t ns2 = na2 / 3 + nf; // 移位后问题根长(radicand = a2*B^(3nf))
786 mp_size_t ns0 = (nl + 2) / 3; // 原问题根长
787 mp_size_t nR = ns0 + 1; // 根工作长度(含可能的最高零 limb)
788 mp_ptr tp = TALLOC_TYPE(6 * ns2 + 4, mp_limb_t);
789 // nf==0 时被开方数即 a2 本身,rad 直接复用(knorm 后 a2 不再读取);
790 // nf>0 时 rad = a2*B^(3nf) 须另建(低位补零后拷贝)。两种形下缓冲均
791 // 覆盖 divide 的 [rad,3ns2) 与余数修正的 [rad,2ns2+3)
792 mp_ptr rad;
793 if (nf) {
794 rad = TALLOC_TYPE(3 * ns2, mp_limb_t);
795 lmmp_zero(rad, 3 * nf);
796 lmmp_copy(rad + 3 * nf, a2, na2);
797 } else {
798 rad = a2;
799 }
800
801 // divide 写满 [dsts,ns2)(根顶 limb 恒非零),仅补零可能的最高空 limb
802 lmmp_zero(dsts + ns2, nR - ns2);
803 /*
804 dstr 路径基于恒等式(K = k*2^t,radicand = X*K^3):
805
806 S = floor(K*cbrt(X)) = K*r + e, e = S mod K < K < 2^72
807 R = radicand - S^3 (divide 以 calr=1 维护)
808 K^3*rem = radicand - (S-e)^3 = R + 3*S^2*e - 3*S*e^2 + e^3
809
810 即 rem = (R + 3*S^2*e - 3*S*e^2 + e^3) / K^3,各除法/移位均精确整除。
811 注意 K^3 | R 单独不成立(e ≠ 0 一般),e 的修正项不可省略。e 的至多
812 2 个 limb 由根还原步骤的返回值免费给出:
813 e_lo = S mod 2^t (shr_ 移出低位)
814 e_hi = (S>>t) mod k(div_1 余数)
815 3*S^2*e 等项均为 e <= 2 limb 的 O(n) 小乘,唯一超线性操作是 S 的
816 平方,免去 r^3 的 sqr + mul 两次全尺寸乘法。k==1 且 t==0 时 e=0
817 且 radicand == X,R 即真余数,走直接下拷快路径。
818 */
819 int remnorm = dstr != NULL && k == 1 && t == 0;
820 lmmp_cbrt_divide_(dsts, rad, ns2, tp, dstr != NULL);
821
822 mp_ptr Sp = NULL;
823 if (dstr && !remnorm) {
824 // S 暂存:随后的还原会原地改写 dsts(>>t 与 div_1(k)),而修正项
825 // 仍需还原前的 S,故先复制(e 依赖还原返回值,无法重排避免)
826 Sp = TALLOC_TYPE(ns2, mp_limb_t);
827 lmmp_copy(Sp, dsts, ns2);
828 }
829 mp_limb_t elo = 0;
830 if (t) {
831 mp_limb_t sc = lmmp_shr_(dsts, dsts, nR, t);
832 if (Sp) elo = sc >> (LIMB_BITS - t);
833 }
834 mp_limb_t ehi = k > 1 ? lmmp_div_1_(dsts, dsts, nR, k) : 0;
835
836 if (dstr) {
837 // remnorm 时 na ≡ 0 (mod 3) 且 hb 满偏,ns2 == ns0,R 区域长度恰合
838 if (remnorm) {
839 lmmp_copy(dstr, rad, 2 * ns0 + 1);
840 TEMP_FREE;
841 return;
842 }
843 // e = ehi*2^t + elo(ehi < k <= 256, elo < 2^t,e < K < 2^72)
844 mp_limb_t e0, e1;
845 if (t == 0) {
846 e0 = ehi;
847 e1 = 0;
848 } else {
849 e0 = elo | (ehi << t);
850 e1 = ehi >> (LIMB_BITS - t);
851 }
852
853 mp_size_t L = 2 * ns2 + 3;
854 mp_ptr N = rad;
855 lmmp_zero(N + 2 * ns2 + 1, L - (2 * ns2 + 1));
856
857 if (e0 | e1) {
858 mp_ptr s2v = TALLOC_TYPE(2 * ns2, mp_limb_t);
859 mp_ptr tb = TALLOC_TYPE(2 * ns2 + 2, mp_limb_t);
860 // N += 3*S^2*e,pe = [tb, 2*ns2+2) = S^2*e
861 lmmp_sqr_(s2v, Sp, ns2);
862 mp_limb_t cy = lmmp_mul_1_(tb, s2v, 2 * ns2, e0);
863 tb[2 * ns2] = cy;
864 tb[2 * ns2 + 1] = 0;
865 if (e1) {
866 // addmul 窗口顶为 limb 2*ns2,返回进位归属 limb 2*ns2+1
867 tb[2 * ns2 + 1] = lmmp_addmul_1_(tb + 1, s2v, 2 * ns2, e1);
868 }
869 cy = lmmp_addmul_1_(N, tb, 2 * ns2 + 2, 3);
870 if (cy)
871 cy = lmmp_add_1_(N + 2 * ns2 + 2, N + 2 * ns2 + 2, L - 2 * ns2 - 2, cy);
872 lmmp_debug_assert(cy == 0);
873
874 mp_limb_t eb[2] = {e0, e1}, e2b[4], e3b[6];
875 lmmp_sqr_hard_2_(e2b, eb);
876 lmmp_mul_basecase_(e3b, e2b, 4, eb, 2);
877 cy = lmmp_add_(N, N, L, e3b, 6);
878 lmmp_debug_assert(cy == 0);
879
880 // N -= 3*S*e^2(e^2 至多 3 limb <= ns2);低窗内可能需向高位借位
881 mp_size_t ne2 = 4;
882 while (ne2 > 1 && e2b[ne2 - 1] == 0) --ne2;
883 lmmp_mul_(tb, Sp, ns2, e2b, ne2);
884 mp_limb_t bo = lmmp_submul_1_(N, tb, ns2 + ne2, 3);
885 if (bo)
886 bo = lmmp_sub_1_(N + ns2 + ne2, N + ns2 + ne2, L - ns2 - ne2, bo);
887 lmmp_debug_assert(bo == 0); // N = K^3*rem >= 0
888 }
889
890 // rem = (N/k^3) >> (3t)
891 if (k > 1)
892 lmmp_div_1_(N, N, L, k * k * k);
893 mp_size_t w = 3 * t / LIMB_BITS, b = 3 * t % LIMB_BITS;
894 mp_ptr rp = N + w;
895 if (b)
896 lmmp_shr_(rp, rp, L - w, b);
897 // w <= 2 且 ns2 >= ns0 保证 L - w >= 2*ns0 + 1,拷贝即写满余数区
898 lmmp_debug_assert(L - w >= 2 * ns0 + 1);
899 lmmp_copy(dstr, rp, 2 * ns0 + 1);
900 TEMP_FREE;
901 return;
902 }
903 TEMP_FREE;
904}
static mp_size_t lmmp_cbrt_snorm_(mp_srcptr numa, mp_size_t na, mp_ptr a2, mp_size_t *na2p)
定义 cbrt.c:635
static void lmmp_cube_6_(mp_ptr restrict t, mp_srcptr restrict r)
计算 [t,6]=[r,2]^3
定义 cbrt.c:51
static mp_size_t lmmp_cbrt_knorm_(mp_srcptr numa, mp_size_t na, mp_ptr a2, mp_size_t *na2p, mp_limb_t *kp)
定义 cbrt.c:320
static void lmmp_cube_3_(mp_ptr restrict dst, mp_limb_t a)
定义 cbrt.c:38
#define rp
#define lmmp_sqr_
mp_limb_t * mp_ptr
定义 lmmp.h:96
#define lmmp_copy(dst, src, n)
定义 lmmp.h:474
#define lmmp_zero(dst, n)
定义 lmmp.h:476
#define lmmp_debug_assert(x)
定义 lmmp.h:498
mp_limb_t lmmp_div_1_(mp_ptr dstq, mp_srcptr numa, mp_size_t na, mp_limb_t x)
单精度数除法
定义 div.c:137
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]
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
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]
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
static mp_limb_t lmmp_sub_1_(mp_ptr dst, mp_srcptr numa, mp_size_t na, mp_limb_t x)
减单精度数静态内联函数 [dst,na]=[numa,na]-x
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
void lmmp_sqr_hard_2_(mp_ptr dst, mp_srcptr numa)
#define a2
#define tp
#define CBRT_INVNEWTON_K_THRESHOLD
#define CBRT_INVNEWTON_NF_MIN
mp_limb_t lmmp_cbrt_3_(mp_limb_t a0, mp_limb_t a1, mp_limb_t a2)
计算算数立方根 floor(cbrt(a0+a1*B+a2*B^2))
void lmmp_cbrt_newton_(mp_ptr dsts, mp_srcptr numa, mp_size_t na, mp_size_t nf)
计算近似立方根 [dsts,na/3+nf+1]=[floor|round](cbrt([numa,na]*B^(3*nf))), 输入须已归一化:na ≡ 0 (mod 3) 且顶 limb >= B...
定义 cbrt.c:688
ulong lmmp_cbrt_ulong_(ulong n)
计算算数立方根 floor(cbrt(n))
void lmmp_cbrt_6_(mp_ptr dst, mp_srcptr numa, mp_size_t na)
计算算术立方根 floor(cbrt([numa,na]))
void lmmp_cbrt_divide_(mp_ptr dst, mp_ptr numa, mp_size_t ns, mp_ptr tp, int calr)
计算算术立方根 floor(cbrt([numa,3*ns]))
#define TEMP_DECL
#define TEMP_FREE
#define TALLOC_TYPE(n, type)

引用了 a2, CBRT_INVNEWTON_K_THRESHOLD, CBRT_INVNEWTON_NF_MIN, k, LIMB_BITS, lmmp_add_(), lmmp_add_1_(), lmmp_addmul_1_(), lmmp_cbrt_(), lmmp_cbrt_3_(), lmmp_cbrt_6_(), lmmp_cbrt_divide_(), lmmp_cbrt_knorm_(), lmmp_cbrt_newton_(), lmmp_cbrt_snorm_(), lmmp_cbrt_ulong_(), lmmp_copy, lmmp_cube_3_(), lmmp_cube_6_(), lmmp_debug_assert, lmmp_div_1_(), lmmp_mul_(), lmmp_mul_1_(), lmmp_mul_basecase_(), lmmp_shr_(), lmmp_sqr_, lmmp_sqr_hard_2_(), lmmp_sub_1_(), lmmp_sub_n_(), lmmp_submul_1_(), lmmp_zero, rp, t, TALLOC_TYPE, TEMP_DECL, TEMP_FREE , 以及 tp.

被这些函数引用 lmmp_cbrt_(), lmmp_invcbrt_newton_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_cbrt_3_()

mp_limb_t lmmp_cbrt_3_ ( mp_limb_t a0,
mp_limb_t a1,
mp_limb_t a2 )

计算算数立方根 floor(cbrt(a0+a1*B+a2*B^2))

参数
a0低位 limb
a1中位 limb
a2高位 limb
警告
a1和a2应至少有一个大于0
注解
a2可以为0,但a1需要大于0,即这个数至少应有65个bit
返回
floor(cbrt(a0+a1*B+a2*B^2))

在文件 cbrt_1.c 第 63 行定义.

63 {
64 lmmp_param_assert(a1 > 0 || a2 > 0);
65 mp_limb_t x[2];
66 /* exact high 65 bits */
67 mp_limb_t a_hi;
68 mp_bitcnt_t bits;
69 if (a2 == 0) {
71 bits = LIMB_BITS + a1_bits;
72 a1_bits--;
73 if (a1_bits == 0)
74 a_hi = a0;
75 else
76 a_hi = (a1 << (LIMB_BITS - a1_bits)) | (a0 >> a1_bits);
77 } else {
79 bits = LIMB_BITS * 2 + a2_bits;
80 a2_bits--;
81 if (a2_bits == 0)
82 a_hi = a1;
83 else
84 a_hi = (a2 << (LIMB_BITS - a2_bits)) | (a1 >> a2_bits);
85 }
86 lmmp_debug_assert(bits >= 65);
87
88 x[1] = bits - 1;
89 x[0] = log2_fixed_64(a_hi);
90
91 mp_limb_t rem = lmmp_div3_(x, x, 2);
92 if (2 * rem >= 3) // round
93 lmmp_inc(x);
94
95 mp_bitcnt_t shift = x[1];
96 x[0] = exp2_fixed_64(x[0]);
97
98 lmmp_debug_assert(shift <= 64);
99 mp_limb_t r;
100 if (shift == 64)
101 r = LIMB_MAX;
102 else
103 r = (x[0] >> (64 - shift)) | (1ULL << shift);
104
105 // log2/exp2 固定精度近似存在 +-2 ulp 的误差,用单调立方比较修正
106 // 到精确 floor:先降后升,两个循环均在真值处终止。
107 mp_limb_t t[3], a[3] = {a0, a1, a2};
108 lmmp_cube_3_(t, r);
109 while (lmmp_cmp_(t, a, 3) > 0) {
110 --r;
111 lmmp_cube_3_(t, r);
112 }
113 while (r < LIMB_MAX) {
114 lmmp_cube_3_(t, r + 1);
115 if (lmmp_cmp_(t, a, 3) > 0) break;
116 ++r;
117 }
118 return r;
119}
static mp_limb_t lmmp_div3_(mp_ptr q, mp_srcptr a, mp_size_t n)
#define lmmp_limb_bits_
size_t mp_bitcnt_t
定义 lmmp.h:98
#define LIMB_MAX
定义 lmmp.h:105
#define lmmp_inc(p)
加1宏(预期无进位)
int lmmp_cmp_(mp_srcptr numa, mp_srcptr numb, mp_size_t n)
比较函数
定义 cmp.c:26
uint64_t exp2_fixed_64(uint64_t x)
计算 floor(exp2(x/B)*B-B), B=2^64
uint64_t log2_fixed_64(uint64_t x)
Copyright (C) 2026 HJimmyK (Jericho Knox)

引用了 a0, a1, a2, exp2_fixed_64(), LIMB_BITS, LIMB_MAX, lmmp_cbrt_3_(), lmmp_cmp_(), lmmp_cube_3_(), lmmp_debug_assert, lmmp_div3_(), lmmp_inc, lmmp_limb_bits_, lmmp_param_assert, log2_fixed_64() , 以及 t.

被这些函数引用 lmmp_cbrt_(), lmmp_cbrt_3_(), lmmp_cbrt_6_fast_(), lmmp_cbrt_divide_(), lmmp_invsqrt_newton_() , 以及 TEST_CASE().

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

◆ lmmp_cbrt_6_()

void lmmp_cbrt_6_ ( mp_ptr dst,
mp_srcptr numa,
mp_size_t na )

计算算术立方根 floor(cbrt([numa,na]))

参数
dst结果指针(2个limb)
numa被开方数指针
na被开方数的 limb 长度
警告
3<na<=6, numa[na-1]!=0, dst!=NULL, numa!=NULL, sep(dst,numa)

在文件 cbrt_1.c 第 274 行定义.

274 {
275 lmmp_param_assert(na > 3 && na <= 6);
276 lmmp_param_assert(dst != NULL && numa != NULL);
277 lmmp_param_assert(numa[na - 1] != 0);
278 mp_limb_t a[6] = {0, 0, 0, 0, 0, 0};
279 for (mp_size_t i = 0; i < na; i++) a[i] = numa[i];
280 if (na == 6 && a[5] >= CBRT_DIVIDE_MIN) {
281 // cbrt_3 种子 + 除法修正:比 log2/exp2 估计更快(条件与
282 // cbrt_divide_ 相同,保证 div_s 的 MSB 归一化要求)
283 mp_limb_t tp[10];
284 lmmp_cbrt_6_fast_(dst, a, tp);
285 return;
286 }
287 mp_limb_t t[10];
288 lmmp_cbrt_6_est_(dst, numa, na);
289 lmmp_cbrt_6_fix_(dst, a, t);
290}
#define CBRT_DIVIDE_MIN
Copyright (C) 2026 HJimmyK (Jericho Knox)
定义 cbrt.c:36
static void lmmp_cbrt_6_est_(mp_ptr r, mp_srcptr numa, mp_size_t n)
static void lmmp_cbrt_6_fix_(mp_ptr r, mp_srcptr a, mp_ptr t)
void lmmp_cbrt_6_fast_(mp_ptr dst, mp_ptr numa, mp_ptr tp)
计算算术立方根 [dst,2] = floor(cbrt([numa,6]))

引用了 CBRT_DIVIDE_MIN, lmmp_cbrt_6_(), lmmp_cbrt_6_est_(), lmmp_cbrt_6_fast_(), lmmp_cbrt_6_fix_(), lmmp_param_assert, t , 以及 tp.

被这些函数引用 lmmp_cbrt_(), lmmp_cbrt_6_(), lmmp_invcbrt_newton_(), lmmp_invsqrt_newton_() , 以及 TEST_CASE().

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

◆ lmmp_cbrt_6_fast_()

void lmmp_cbrt_6_fast_ ( mp_ptr dst,
mp_ptr numa,
mp_ptr tp )

计算算术立方根 [dst,2] = floor(cbrt([numa,6]))

参数
dst结果指针(2个limb)
numa被开方数指针(6个limb,会被修改;返回时 [numa,5] 储存余数,即[numa,6] - [dst,2]^3)
tp临时指针(至少8个limb)
警告
numa[5]>=0x6000000000000000, dst!=NULL, numa!=NULL, tp!=NULL, sep(dst,numa,tp)
注解
cbrt_6_ 的 na==6 快速路径;余数是修正循环的副产物,无需额外计算。

引用了 LMMP_API, lmmp_cbrt_6_fast_() , 以及 tp.

被这些函数引用 lmmp_cbrt_6_(), lmmp_cbrt_6_fast_(), lmmp_cbrt_6_fast_(), lmmp_cbrt_divide_() , 以及 TEST_CASE().

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

◆ lmmp_cbrt_chebyshev_()

ulong lmmp_cbrt_chebyshev_ ( ulong n)

计算算数立方根 floor(cbrt(n))

参数
n被开方数
返回
floor(cbrt(n))
警告
n>0
注解
使用Chebyshev估计,当n较大时,此算法更占优势

在文件 cbrt_ulong.c 第 47 行定义.

47 {
49 typedef union {
50 ulong uword_val;
51 double double_val;
52 } uni;
53
54 int rem, mul;
55 double factor, root, dec, dec2;
56 ulong ret, expo, table_index;
57 uni alias;
58
59 /* upper_limit is the max cube root possible for one word */
60
61 const ulong upper_limit = 2642245; /* 2642245 < (2^64)^(1/3) */
62 const ulong expo_mask = 0x7FF0000000000000; /* exponent bits in double */
63 const ulong mantissa_mask = 0x000FFFFFFFFFFFFF; /* mantissa bits in float */
64 const ulong table_mask = 0x000F000000000000; /* first 4 bits of mantissa */
65 const uint mantissa_bits = 52;
66 const ulong bias_hex = 0x3FE0000000000000;
67 const uint bias = 1022;
68 alias.double_val = (double)n;
69
70 expo = alias.uword_val & expo_mask; /* extracting exponent */
71 expo >>= mantissa_bits;
72 expo -= bias; /* Subtracting bias */
73
74 /* extracting first 4 bits of mantissa, this will help select correct poly */
75 /* note mantissa of 0.5 is 0x0000000000000 not 0x1000000000000 */
76
77 table_index = alias.uword_val & table_mask;
78 table_index >>= (mantissa_bits - 4);
79
80 /* extracting decimal part, 0.5 <= dec <= 1 */
81 ret = alias.uword_val & mantissa_mask;
82 ret |= bias_hex;
83 alias.uword_val = ret;
84 dec = alias.double_val;
85
86 rem = expo % 3;
87 expo /= 3;
88 factor = factor_table[rem];
89
90 /* Calculating cube root of dec using chebyshev approximation polynomial */
91
92 dec2 = dec * dec;
93 root = (coeff[table_index][0] + coeff[table_index][1] * dec);
94 root += (coeff[table_index][2] * dec2);
95
96 mul = (ulong)1 << expo; /* mul = 2^expo */
97 root *= mul; /* dec^(1/3) * 2^(expo/3) */
98 root *= factor; /* root*= (expo%3)^(1/3) */
99 ret = root;
100
101 /* In case ret^3 or (ret+1)^3 will cause overflow */
102
103 if (ret >= upper_limit) {
104 if (n >= upper_limit * upper_limit * upper_limit)
105 return upper_limit;
106 ret = upper_limit - 1;
107 }
108 while (ret * ret * ret <= n) {
109 (ret) += 1;
110 if (ret == upper_limit)
111 break;
112 }
113 while (ret * ret * ret > n) (ret) -= 1;
114
115 return ret;
116}
static const float coeff[16][3]
static const float factor_table[]
Copyright (C) 2026 HJimmyK (Jericho Knox)

引用了 coeff, factor_table, lmmp_cbrt_chebyshev_(), lmmp_param_assert , 以及 n.

被这些函数引用 lmmp_cbrt_chebyshev_(), lmmp_cbrt_ulong_(), lmmp_invsqrt_newton_() , 以及 TEST_CASE().

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

◆ lmmp_cbrt_divide_()

void lmmp_cbrt_divide_ ( mp_ptr dst,
mp_ptr numa,
mp_size_t ns,
mp_ptr tp,
int calr )

计算算术立方根 floor(cbrt([numa,3*ns]))

参数
dst结果指针(ns个limb)
numa被开方数指针(3*ns个limb,且会被修改,若计算余数,余数存储在[numa,2*ns+1]中)
ns结果指针的 limb 长度
tp临时指针(6*ns+4个limb)
calr是否计算余数(0表示不计算余数,1表示计算余数)
警告
numa[3*ns-1]>=0x6000000000000000, dst!=NULL, numa!=NULL, tp!=NULL, sep(dst,numa,tp)
注解
即使输入calr=0,numa也会被修改,如果calr=1,则[numa,2*ns+1]将会储存余数。

引用了 LMMP_API, lmmp_cbrt_divide_() , 以及 tp.

被这些函数引用 lmmp_cbrt_(), lmmp_cbrt_divide_(), lmmp_cbrt_divide_() , 以及 TEST_CASE().

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

◆ lmmp_cbrt_newton_()

void lmmp_cbrt_newton_ ( mp_ptr dsts,
mp_srcptr numa,
mp_size_t na,
mp_size_t nf )

计算近似立方根 [dsts,na/3+nf+1]=[floor|round](cbrt([numa,na]*B^(3*nf))), 输入须已归一化:na ≡ 0 (mod 3) 且顶 limb >= B/8

参数
dsts目标数组(长度至少 na/3+nf+1 个limb)
numa输入数组(长度为 na 个limb,已 3 对齐归一化)
nanuma数组的 limb 长度(3 的倍数)
nf精度因子
警告
na>0, na%3==0, numa[na-1]>=B/8, nf>=2, 3*nf>=2*na+3, dsts!=NULL, numa!=NULL, sep(dsts,numa)
注解
设 x = cbrt([numa,na]*B^(3*nf))(实数),round 为四舍五入(恰为 1/2 时进位), 则结果恰为 round(x-eps),其中 0 <= eps < 2^-62。eps 非负,故结果绝不超过 round(x);仅当 x 的小数部分落在 [1/2, 1/2+eps) 时得到 floor(x) 而非 floor(x)+1(随机输入下概率 < 2^-62),此即 [floor|round] 的确切含义。

在文件 cbrt.c 第 688 行定义.

688 {
689 lmmp_param_assert(na > 0 && na % 3 == 0);
690 lmmp_param_assert(nf >= 2);
691 lmmp_param_assert(3 * nf >= 2 * na + 3);
692 lmmp_param_assert(numa != NULL && dsts != NULL);
693 lmmp_param_assert(numa[na - 1] >= LIMB_B_8);
694
695 TEMP_DECL;
696 mp_size_t ns = na / 3 + nf + 1;
697 mp_ptr ic = TALLOC_TYPE(ns + 1, mp_limb_t);
698 mp_ptr q1 = TALLOC_TYPE(2 * ns + 2, mp_limb_t);
699 mp_ptr q = TALLOC_TYPE(na + 2 * ns + 3, mp_limb_t);
700
701 lmmp_invcbrt_newton_(ic, ns, numa, na);
702
703 // Q = a*ic^2:先平方再单乘(对比 ic*a 后再乘 ic 的两次同规模乘法,
704 // 平方以约半成本替代其一;2*ns+2 >= na 满足 mul 的长操作数在前)
705 lmmp_sqr_(q1, ic, ns + 1);
706 lmmp_mul_(q, q1, 2 * ns + 2, numa, na);
707
708 // dsts = round(Q/2^e0),舍入位为 q[e0-1] 的最高位(结果 <= B^(ns-1),
709 // 进位不会越出 ns limb,无需中间缓冲)
710 mp_size_t e0 = 2 * ns + 2 * (na / 3) - nf;
711 lmmp_copy(dsts, q + e0, ns);
712 if (q[e0 - 1] >> (LIMB_BITS - 1))
713 lmmp_inc(dsts);
714 TEMP_FREE;
715}
#define LIMB_B_8
void lmmp_invcbrt_newton_(mp_ptr dstis, mp_size_t ns, mp_srcptr numa, mp_size_t na)
计算逆立方根的定点下近似:记 I=floor(cbrt(B^(3*ns+na)/[numa,na])), 则 [dstis,ns+1] 满足 I-1 <= [dstis,...

引用了 LIMB_B_8, LIMB_BITS, lmmp_cbrt_newton_(), lmmp_copy, lmmp_inc, lmmp_invcbrt_newton_(), lmmp_mul_(), lmmp_param_assert, lmmp_sqr_, TALLOC_TYPE, TEMP_DECL , 以及 TEMP_FREE.

被这些函数引用 lmmp_cbrt_(), lmmp_cbrt_newton_() , 以及 lmmp_invcbrt_newton_().

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

◆ lmmp_cbrt_ulong_()

ulong lmmp_cbrt_ulong_ ( ulong n)

计算算数立方根 floor(cbrt(n))

参数
n被开方数
返回
floor(cbrt(n))
注解
会依据n的大小,选择合适的算法

在文件 cbrt_ulong.c 第 139 行定义.

139 {
140 double val, x, xcub, num, den;
141 ulong ret, upper_limit;
142
143 if (n < 125)
144 return (n >= 1) + (n >= 8) + (n >= 27) + (n >= 64);
145 if (n < 1331)
146 return 5 + (n >= 216) + (n >= 343) + (n >= 512) + (n >= 729) + (n >= 1000);
147 if (n < 4913)
148 return 11 + (n >= 1728) + (n >= 2197) + (n >= 2744) + (n >= 3375) + (n >= 4096);
149
150 val = (double)n;
151
152 if (n >= 1ULL << 46)
153 return lmmp_cbrt_chebyshev_(n);
154
155 upper_limit = 2642245; /* 2642245 = floor((2^64)^(1/3)) */
156
157 x = lmmp_cbrt_estimate((double)n);
158
159 /* Kahan's iterations to get cube root */
160
161 xcub = x * x * x;
162 num = (xcub - val) * x;
163 den = (xcub + xcub + val);
164 x -= (num / den);
165 ret = x;
166
167 if (ret >= upper_limit) {
168 if (n >= upper_limit * upper_limit * upper_limit)
169 return upper_limit;
170 ret = upper_limit - 1;
171 }
172 while (ret * ret * ret <= n) {
173 (ret) += 1;
174 if (ret == upper_limit)
175 break;
176 }
177 while (ret * ret * ret > n) (ret) -= 1;
178
179 return ret;
180}
static double lmmp_cbrt_estimate(double a)
ulong lmmp_cbrt_chebyshev_(ulong n)
计算算数立方根 floor(cbrt(n))

引用了 lmmp_cbrt_chebyshev_(), lmmp_cbrt_estimate(), lmmp_cbrt_ulong_() , 以及 n.

被这些函数引用 lmmp_cbrt_(), lmmp_cbrt_ulong_(), lmmp_invsqrt_newton_(), lmmp_nthroot_ulong_(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_divexact_()

void lmmp_divexact_ ( mp_ptr dst,
mp_srcptr np,
mp_size_t nn,
mp_srcptr dp,
mp_size_t dn )

精确除法([dst,nn]=[np,nn]/[dp,dn],且余数必须为0)

参数
dst结果指针(长度为 nn-dn+1 个limb)
np被除数指针(长度为 nn 个limb)
nn被除数的 limb 长度
dp除数指针(长度为 dn 个limb)
dn结除数的 limb 长度
警告
dp[0]%2==1, nn>=dn>0, dst!=NULL, np!=NULL, dp!=NULL, eqsep(dst,np), sep([dst|np],dp)

引用了 LMMP_API, lmmp_divexact_(), lmmp_gcd_11_(), lmmp_gcd_1_(), lmmp_gcd_22_(), lmmp_gcd_2_() , 以及 lmmp_gcd_lehmer_().

被这些函数引用 bench_divexact(), lmmp_divexact_(), lmmp_divexact_(), lmmp_gcdext_derive_(), lmmp_odd_nCr_div_(), make_divexact_ctx(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_divexact_1_()

void lmmp_divexact_1_ ( mp_ptr dst,
mp_srcptr np,
mp_size_t nn,
mp_limb_t d,
mp_limb_t dinv )

精确除法([dst,nn]=[np,nn]/d,且余数必须为0)

Copyright (C) 2026 HJimmyK (Jericho Knox)

参数
dst结果指针(长度为 nn 个limb)
np被除数指针(长度为 nn 个limb)
nn被除数的 limb 长度
d除数
dinv除数的逆元(d*dinv==1 mod 2^64)
警告
d%2==1, d*dinv==1 mod 2^64, nn>0, dst!=NULL, np!=NULL, eqsep(dst,np)

精确除法([dst,nn]=[np,nn]/d,且余数必须为0)

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

在文件 divexact.c 第 32 行定义.

32 {
33 lmmp_param_assert(d % 2 == 1);
34 lmmp_param_assert(dinv * d == 1);
35 lmmp_param_assert(nn > 0);
36 lmmp_debug_assert(dst != NULL && np != NULL);
37 mp_limb_t c = 0;
38 mp_limb_t l, s, lo, hi, q;
39 mp_size_t i;
40 for (i = 0; i < nn - 1; i++) {
41 s = np[i];
42 l = s - c;
43 c = l > s;
44 q = l * dinv;
45 dst[i] = q;
46 _umul64to128_(q, d, &lo, &hi);
47 c += hi;
48 }
49 s = np[i];
50 l = s - c;
51 c = l > s;
52 q = l * dinv;
53 dst[i] = q;
54 lmmp_debug_assert(c == 0);
55}
#define s
#define lo

引用了 _umul64to128_(), lmmp_debug_assert, lmmp_divexact_1_(), lmmp_param_assert, lo , 以及 s.

被这些函数引用 lmmp_binvert_(), lmmp_divexact_(), lmmp_divexact_1_(), lmmp_divexact_basecase_() , 以及 TEST_CASE().

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

◆ lmmp_divexact_2_()

void lmmp_divexact_2_ ( mp_ptr dst,
mp_srcptr np,
mp_size_t nn,
mp_srcptr dp,
mp_srcptr dinv )

精确除法([dst,nn]=[np,nn]/[dp,2],且余数必须为0)

参数
dst结果指针(长度为 nn-1 个limb)
np被除数指针(长度为 nn 个limb)
nn被除数的 limb 长度
dp除数指针(长度为 2 个limb)
dinv除数的逆元指针(长度为 2 个limb)
警告
dp[0]%2==1, dp*dinv==1 mod 2^128, nn>1, dst!=NULL, np!=NULL, dp!=NULL, dinv!=NULL eqsep(dst,np), sep(dp,dinv,[dst|np])

引用了 LMMP_API , 以及 lmmp_divexact_2_().

被这些函数引用 lmmp_divexact_(), lmmp_divexact_2_(), lmmp_divexact_2_() , 以及 TEST_CASE().

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

◆ lmmp_divexact_basecase_()

void lmmp_divexact_basecase_ ( mp_ptr dst,
mp_ptr np,
mp_size_t nn,
mp_srcptr dp,
mp_size_t dn )

精确除法([dst,nn-dn+1]=[np,nn]/[dp,dn],且余数必须为0),朴素算法

参数
dst结果指针(长度为 nn-dn+1 个limb)
np被除数指针(长度为 nn 个limb),将会被覆写为全零
nn被除数的 limb 长度
dp除数指针(长度为 dn 个limb)
dn除数的 limb 长度
警告
dp[0]%2==1, nn>=dn>0, dst!=NULL, np!=NULL, dp!=NULL, eqsep(dst,np), sep(dp,[dst|np])
注解
若dst==np,将会覆写 [dst,nn] 区域,其中 [dst,nn-dn+1] 为商,[dst+nn-dn+1,dn-1] 将会被覆写为0

引用了 LMMP_API , 以及 lmmp_divexact_basecase_().

被这些函数引用 lmmp_divexact_(), lmmp_divexact_basecase_(), lmmp_divexact_basecase_() , 以及 TEST_CASE().

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

◆ lmmp_divexact_divide_()

void lmmp_divexact_divide_ ( mp_ptr dst,
mp_srcptr np,
mp_size_t nn,
mp_srcptr dp,
mp_size_t dn )

精确除法([dst,nn]=[np,nn]/[dp,dn],且余数必须为0),分治算法

参数
dst结果指针(长度为 nn-dn+1 个limb)
np被除数指针(长度为 nn 个limb)
nn被除数的 limb 长度
dp除数指针(长度为 dn 个limb)
dn结除数的 limb 长度
警告
dp[0]%2==1, nn>=dn>0, dn>=nn-dn+1, dst!=NULL, np!=NULL, dp!=NULL, sep(dst,np,dp)

引用了 LMMP_API , 以及 lmmp_divexact_divide_().

被这些函数引用 lmmp_divexact_(), lmmp_divexact_divide_(), lmmp_divexact_divide_() , 以及 TEST_CASE().

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

◆ lmmp_divexact_unbalance_()

void lmmp_divexact_unbalance_ ( mp_ptr dst,
mp_srcptr np,
mp_size_t nn,
mp_srcptr dp,
mp_size_t dn,
mp_ptr dinv )

精确除法([dst,nn]=[np,nn]/[dp,dn],且余数必须为0)

参数
dst结果指针(长度为 nn-dn+1 个limb)
np被除数指针(长度为 nn 个limb),将会被修改为全零
nn被除数的 limb 长度
dp除数指针(长度为 dn 个limb)
dn结除数的 limb 长度
dinv除数[dp,dn]关于B^dn的逆元,若为NULL,则自动计算
警告
dp[0]%2==1, nn>=dn>0, dst!=NULL, np!=NULL, dp!=NULL, eqsep(dst,np), sep(dp,dinv,[dst|np])
注解
若dst==np,只会覆写 [dst,nn-dn+1] 区域

引用了 LMMP_API , 以及 lmmp_divexact_unbalance_().

被这些函数引用 lmmp_divexact_(), lmmp_divexact_unbalance_(), lmmp_divexact_unbalance_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_factorial_()

mp_size_t lmmp_factorial_ ( mp_ptr dst,
mp_bitcnt_t bits,
mp_size_t rn,
uint n )

计算 n!

阶乘

参数
dst结果指针
bitsn! 的2的因子数
rn结果指针的 limb 长度
n阶乘的阶数
警告
dst!=NULL, rn>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API, lmmp_factorial_() , 以及 n.

被这些函数引用 bench_factorial(), lmmp_factorial_(), lmmp_factorial_(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), test_fn_heap_balance_full_cycle(), test_fn_lifecycle_idempotent() , 以及 thread_worker().

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

◆ lmmp_factorial_size_()

mp_size_t lmmp_factorial_size_ ( uint n,
mp_bitcnt_t * bits )

计算 n!

阶乘的 limb 缓冲区长度

参数
n阶乘的阶数
bits被修改为 n! 的2的因子数
警告
bits!=NULL
返回
n! 阶乘的 limb 缓冲区长度(比实际长度多)

引用了 LMMP_API, lmmp_factorial_size_() , 以及 n.

被这些函数引用 bench_factorial(), lmmp_factorial_size_(), lmmp_factorial_size_(), lmmp_odd_nCr_uint_(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), test_fn_heap_balance_full_cycle(), test_fn_lifecycle_idempotent(), test_fn_thread_isolation() , 以及 thread_worker().

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

◆ lmmp_fibonacci2_()

mp_size_t lmmp_fibonacci2_ ( mp_ptr dst,
mp_ptr dst2,
mp_size_t rn,
ulong n )

计算 Fibonacci 数对:[dst,rn] = F[n],[dst2,rn] = F[n-1]

参数
dstF[n] 结果指针
dst2F[n-1] 结果指针
rndst 与 dst2 各自的 limb 缓冲区长度
nFibonacci 数列的下标
警告
dst!=NULL, dst2!=NULL, sep(dst,dst2), rn>=lmmp_fibonacci_size_(n)
返回
F[n] 的实际 limb 长度(n==0时,返回1);F[n-1] 的实际长度为ret-(dst2[ret-1]==0),至多比返回值少1

在文件 fibonacci.c 第 193 行定义.

193 {
194 lmmp_param_assert(dst != NULL && dst2 != NULL);
195#if LMMP_DEBUG_PARAM_ASSERT_CHECK == 1
197 lmmp_param_assert(rn >= need);
198#endif
199 if (n <= FIB_TABLE_LIMIT) {
200 dst[0] = fib_table[n + 1]; /* F[n] */
201 dst2[0] = fib_table[n]; /* F[n-1],n==0 时即 F[-1]=1 */
202 return 1;
203 }
204 TEMP_DECL;
206 mp_size_t size = fib2_core_(dst, dst2, tp, rn, n);
207 TEMP_FREE;
208 return size;
209}
static mp_size_t fib2_core_(mp_ptr fp, mp_ptr f1p, mp_ptr tp, mp_size_t alloc, ulong n)
Fibonacci 数对倍增核心:fp <- F[n],f1p <- F[n-1]
#define FIB_TABLE_LIMIT
Copyright (C) 2026 HJimmyK (Jericho Knox)
static const mp_limb_t fib_table[93+2]
mp_size_t lmmp_fibonacci_size_(ulong n)
计算 Fibonacci 数 F[n](及 F[n-1])所需的 limb 缓冲区长度

引用了 fib2_core_(), fib_table, FIB_TABLE_LIMIT, lmmp_fibonacci2_(), lmmp_fibonacci_size_(), lmmp_param_assert, n, TALLOC_TYPE, TEMP_DECL, TEMP_FREE , 以及 tp.

被这些函数引用 fib_pair(), lmmp_fibonacci2_(), lmmp_pow_(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_fibonacci_()

mp_size_t lmmp_fibonacci_ ( mp_ptr dst,
mp_size_t rn,
ulong n )

计算 Fibonacci 数 [dst,rn] = F[n]

参数
dst结果指针
rndst 的 limb 缓冲区长度
nFibonacci 数列的下标
警告
dst!=NULL, rn>=lmmp_fibonacci_size_(n)
返回
F[n] 的实际 limb 长度(n==0 时 返回 0)

在文件 fibonacci.c 第 211 行定义.

211 {
212 lmmp_param_assert(dst != NULL);
213#if LMMP_DEBUG_PARAM_ASSERT_CHECK == 1
215 lmmp_param_assert(rn >= need);
216#else
217 (void)rn;
218#endif
219 if (n <= FIB_TABLE_LIMIT) {
220 dst[0] = fib_table[n + 1]; /* F[n],n==0 时为0 */
221 return (n == 0) ? 0 : 1;
222 }
223
224 /* k = n/2,先算出 (F[k], F[k-1]),再一次乘法合并。
225 limbs_bound(n2)+2 同时覆盖核心循环(2*limbs(F[n2>>1])+1)与
226 合并操作数 xp/yp 的写入(size+2)*/
227 ulong n2 = n >> 1;
228 mp_size_t xalloc = fib_limbs_bound_(n2) + 2;
229 TEMP_DECL;
230 mp_ptr xp = TALLOC_TYPE(xalloc, mp_limb_t);
231 mp_ptr yp = TALLOC_TYPE(xalloc, mp_limb_t);
232 mp_ptr tp = TALLOC_TYPE(xalloc, mp_limb_t);
233 mp_size_t size = fib2_core_(xp, yp, tp, xalloc, n2);
234 mp_size_t xsize, ysize;
235
236 if (n & 1) {
237 /* F[2k+1] = (2F[k]+F[k-1]) * (2F[k]-F[k-1]) + 2*(-1)^k */
238 mp_limb_t c2 = lmmp_shl_(dst, xp, size, 1); /* dst 暂存 2F[k] 低 size 位 */
239 mp_limb_t c = lmmp_add_n_(xp, dst, yp, size);
240 c += c2; /* 2F[k] 的溢出位并入最高 limb,c=[0|1|2] */
241 xp[size] = c;
242 xsize = size + (c != 0);
243 c2 -= lmmp_sub_n_(yp, dst, yp, size); /* yp = 2F[k]-F[k-1],c2=[0|1] */
244 lmmp_debug_assert(c2 <= 1);
245 yp[size] = c2;
246 ysize = size + c2;
247
248 lmmp_mul_(dst, xp, xsize, yp, ysize);
249 size = xsize + ysize;
250 if (n & 2) {
251 mp_limb_t b = lmmp_sub_1_(dst, dst, size, 2);
252 lmmp_debug_assert(b == 0);
253 } else {
254 mp_limb_t c3 = lmmp_add_1_(dst, dst, size, 2);
255 lmmp_debug_assert(c3 == 0);
256 }
257 } else {
258 /* F[2k] = F[k] * (F[k] + 2F[k-1]) */
259 mp_limb_t c = lmmp_addshl1_n_(yp, xp, yp, size); /* yp = F[k]+2F[k-1] */
260 yp[size] = c;
261 ysize = size + (c != 0);
262
263 lmmp_mul_(dst, yp, ysize, xp, size);
264 size += ysize;
265 }
266
267 size -= (dst[size - 1] == 0);
268 TEMP_FREE;
269 return size;
270}
static mp_size_t fib_limbs_bound_(ulong m)
计算 F[m] 的 limb 长度紧上界
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_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_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 xp

引用了 fib2_core_(), fib_limbs_bound_(), fib_table, FIB_TABLE_LIMIT, lmmp_add_1_(), lmmp_add_n_(), lmmp_addshl1_n_(), lmmp_debug_assert, lmmp_fibonacci_(), lmmp_fibonacci_size_(), lmmp_mul_(), lmmp_param_assert, lmmp_shl_(), lmmp_sub_1_(), lmmp_sub_n_(), n, TALLOC_TYPE, TEMP_DECL, TEMP_FREE, tp , 以及 xp.

被这些函数引用 bench_fib(), lmmp_fibonacci_(), lmmp_pow_(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_fibonacci_size_()

mp_size_t lmmp_fibonacci_size_ ( ulong n)

计算 Fibonacci 数 F[n](及 F[n-1])所需的 limb 缓冲区长度

参数
nFibonacci 数列的下标
返回
缓冲区长度,比 F[n] 的实际长度多 2-4 个 limb

在文件 fibonacci.c 第 122 行定义.

122 {
123 if (n <= FIB_TABLE_LIMIT) {
124 return 1;
125 }
126 return 2 * (fib_limbs_bound_(n >> 1) + 1) + 2;
127}

引用了 fib_limbs_bound_(), FIB_TABLE_LIMIT, lmmp_fibonacci_size_() , 以及 n.

被这些函数引用 bench_fib(), fib_pair(), lmmp_fibonacci2_(), lmmp_fibonacci_(), lmmp_fibonacci_size_(), lmmp_pow_(), TEST_CASE(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_gcd_()

mp_size_t lmmp_gcd_ ( mp_ptr dst,
mp_srcptr up,
mp_size_t un,
mp_srcptr vp,
mp_size_t vn )

计算两个无符号整数的最大公约数(通用分发入口)

Copyright (C) 2026 HJimmyK (Jericho Knox)

参数
dst结果指针(长度至少为 min(un,vn))
up第一个无符号整数指针
un第一个无符号整数的 limb 长度
vp第二个无符号整数指针
vn第二个无符号整数的 limb 长度
警告
up!=NULL, un>0, vp!=NULL, vn>0, eqsep(dst,[up|vp]), dst!=NULL, up[un-1]!=0, vp[vn-1]!=0
返回
dst 的实际 limb 长度

计算两个无符号整数的最大公约数(通用分发入口)

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

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

27 {
28 lmmp_param_assert(un > 0 && vn > 0);
29 lmmp_param_assert(up != NULL && vp != NULL && dst != NULL);
30 lmmp_param_assert(up[un - 1] != 0);
31 lmmp_param_assert(vp[vn - 1] != 0);
32
33 if (un < vn) {
34 LMMP_SWAP(up, vp, mp_srcptr);
35 LMMP_SWAP(un, vn, mp_size_t);
36 }
37 // u >= v
38
39 if (vn == 1) {
40 dst[0] = (un == 1) ? lmmp_gcd_11_(up[0], vp[0]) : lmmp_gcd_1_(up, un, vp[0]);
41 return 1;
42 }
43 if (vn == 2) {
44 return (un == 2) ? lmmp_gcd_22_(dst, up, vp) : lmmp_gcd_2_(dst, up, un, vp);
45 }
46 if (un >= GCD_HGCD_THRESHOLD) {
47 return lmmp_gcd_hgcd_(dst, up, un, vp, vn);
48 }
49 return lmmp_gcd_lehmer_(dst, up, un, vp, vn);
50}
#define LMMP_SWAP(x, y, type)
交换两个变量的值
定义 lmmp.h:458
const mp_limb_t * mp_srcptr
定义 lmmp.h:97
#define GCD_HGCD_THRESHOLD
mp_size_t lmmp_gcd_lehmer_(mp_ptr dst, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
计算两个无符号整数的最大公约数(Lehmer算法)
mp_size_t lmmp_gcd_2_(mp_ptr dst, mp_srcptr up, mp_size_t un, mp_srcptr vp)
计算两个无符号整数的最大公约数
mp_limb_t lmmp_gcd_11_(mp_limb_t u, mp_limb_t v)
计算两个无符号整数的最大公约数
定义 gcd_1.c:28
mp_size_t lmmp_gcd_hgcd_(mp_ptr dst, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
计算两个无符号整数的最大公约数(hgcd 分治,长输入优选)
mp_limb_t lmmp_gcd_1_(mp_srcptr up, mp_size_t un, mp_limb_t v)
计算两个无符号整数的最大公约数
定义 gcd_1.c:46
mp_size_t lmmp_gcd_22_(mp_ptr dst, mp_srcptr up, mp_srcptr vp)
计算两个无符号整数的最大公约数
定义 gcd_2.c:60

引用了 GCD_HGCD_THRESHOLD, lmmp_gcd_(), lmmp_gcd_11_(), lmmp_gcd_1_(), lmmp_gcd_22_(), lmmp_gcd_2_(), lmmp_gcd_hgcd_(), lmmp_gcd_lehmer_(), lmmp_param_assert , 以及 LMMP_SWAP.

被这些函数引用 lmmp_gcd_(), small_factor_q(), TEST_CASE(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_gcd_11_()

mp_limb_t lmmp_gcd_11_ ( mp_limb_t u,
mp_limb_t v )

计算两个无符号整数的最大公约数

Copyright (C) 2026 HJimmyK (Jericho Knox)

参数
u第一个无符号整数
v第二个无符号整数
返回
最大公约数
警告
u!=0, v!=0

计算两个无符号整数的最大公约数

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

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

28 {
29 lmmp_param_assert(u > 0 && v > 0);
30 int k = lmmp_tailing_zeros_(u | v); // k = min(tz(u), tz(v))
31 u >>= lmmp_tailing_zeros_(u);
32 v >>= lmmp_tailing_zeros_(v);
33 // u, v 均为奇数;去冗余最低位(隐式最低位表示)
34 u >>= 1;
35 v >>= 1;
36 while (u != v) {
37 mp_limb_t t = u - v;
38 mp_limb_t m = (mp_limb_t)((slong)t >> 63); // u<v -> 1
39 v += m & t; // v = min(u, v)
40 u = (t ^ m) - m; // u = |u - v|
41 u = (u >> 1) >> lmmp_tailing_zeros_(t);
42 }
43 return ((u << 1) + 1) << k;
44}
#define lmmp_tailing_zeros_
int64_t slong
定义 numth.h:41

引用了 k, lmmp_gcd_11_(), lmmp_param_assert, lmmp_tailing_zeros_ , 以及 t.

被这些函数引用 lmmp_divexact_(), lmmp_gcd_(), lmmp_gcd_11_(), lmmp_gcd_1_(), lmmp_gcd_22_(), lmmp_gcd_lehmer_() , 以及 TEST_CASE().

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

◆ lmmp_gcd_1_()

mp_limb_t lmmp_gcd_1_ ( mp_srcptr up,
mp_size_t un,
mp_limb_t v )

计算两个无符号整数的最大公约数

参数
up第一个无符号整数指针
un第一个无符号整数的 limb 长度
v第二个无符号整数
警告
v!=0, up!=NULL, un>0
返回
最大公约数

在文件 gcd_1.c 第 46 行定义.

46 {
47 lmmp_param_assert(un > 0);
48 lmmp_param_assert(v > 0);
49 mp_limb_t ulimb;
50 if (un == 1) {
51 ulimb = up[0];
52 } else {
53 ulimb = lmmp_mod_1_(up, un, v);
54 }
55 if (ulimb == 0)
56 return v;
57 else
58 return lmmp_gcd_11_(ulimb, v);
59}
mp_limb_t lmmp_mod_1_(mp_srcptr numa, mp_size_t na, mp_limb_t x)
单精度数取余
定义 div.c:38

引用了 lmmp_gcd_11_(), lmmp_gcd_1_(), lmmp_mod_1_() , 以及 lmmp_param_assert.

被这些函数引用 lmmp_divexact_(), lmmp_gcd_(), lmmp_gcd_1_(), lmmp_gcd_lehmer_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_gcd_22_()

mp_size_t lmmp_gcd_22_ ( mp_ptr dst,
mp_srcptr up,
mp_srcptr vp )

计算两个无符号整数的最大公约数

参数
up第一个无符号整数指针,长度为 2
vp第二个无符号整数指针,长度为 2
dst结果指针(长度为 2,两个 limb 都会进行写入,即使最高位可能为0)
警告
up!=NULL, vp!=NULL, [up,2]!=0, [vp,2]!=0, dst!=NULL, eqsep(dst,[up|vp])
注解
up 和 vp 的高位允许为 0,但要求任一个数的高低位不能全为 0
返回
dst 的实际 limb 长度

在文件 gcd_2.c 第 60 行定义.

60 {
61 lmmp_param_assert(dst != NULL);
62 lmmp_param_assert(up != NULL);
63 lmmp_param_assert(vp != NULL);
64 lmmp_param_assert(!(up[1] == 0 && up[0] == 0));
65 lmmp_param_assert(!(vp[1] == 0 && vp[0] == 0));
66 mp_limb_t u0 = up[0], u1 = up[1];
67 mp_limb_t v0 = vp[0], v1 = vp[1];
68
69 if ((u1 | v1) == 0) {
70 dst[0] = lmmp_gcd_11_(u0, v0);
71 dst[1] = 0;
72 return 1;
73 }
74
75 // cnt = min(tz(u), tz(v)) 为 gcd 中的 2 因子幂
76 int ku = ctz_u128(u0, u1);
77 int kv = ctz_u128(v0, v1);
78 int cnt = ku < kv ? ku : kv;
79 lshr_u128(&u0, &u1, ku);
80 lshr_u128(&v0, &v1, kv);
81 // u, v 均为奇数;去冗余最低位(隐式最低位表示),腾出符号位
82 u0 = (u0 >> 1) | (u1 << 63);
83 u1 >>= 1;
84 v0 = (v0 >> 1) | (v1 << 63);
85 v1 >>= 1;
86
87 while (u1 | v1) { // 至少一方仍为双 limb
88 mp_limb_t t0 = u0 - v0;
89 mp_limb_t t1 = u1 - v1 - (u0 < v0);
90 mp_limb_t m = -(mp_limb_t)(t1 >> 63); // u<v -> 1
91 if (t0 == 0) {
92 if (t1 == 0)
93 break;
94
95 v1 += m & t1; // v1 = min(u1, v1)(v0 == u0,无需更新)
96 u0 = (t1 ^ m) - m; // |u1 - v1|
97 u0 >>= lmmp_tailing_zeros_(t1) + 1;
98 u1 = 0;
99 } else {
100 int c = lmmp_tailing_zeros_(t0) + 1;
101 // v = min(u, v)(128 位加法 v += m & t)
102 mp_limb_t w0 = m & t0;
103 mp_limb_t w1 = m & t1;
104 v0 += w0;
105 v1 += w1 + (v0 < w0);
106
107 u0 = (t0 ^ m) - m;
108 u1 = t1 ^ m;
109 if (c == 64) {
110 u0 = u1;
111 u1 = 0;
112 } else {
113 u0 = (u0 >> c) | (u1 << (64 - c));
114 u1 >>= c;
115 }
116 }
117 }
118
119 mp_limb_t g0, g1; // 奇数 gcd
120 if (u1 | v1) {
121 g0 = (u0 << 1) | 1;
122 g1 = (u1 << 1) | (u0 >> 63);
123 } else {
124 while ((u0 | v0) >> 63) { // 任一 >= 2^63 则真值 >= 2^64,至多两次迭代
125 mp_limb_t t = u0 - v0;
126 if (t == 0)
127 break; // u == v
128 mp_limb_t m = -(mp_limb_t)(u0 < v0); // 符号掩码
129 v0 += m & t; // v = min(u0, v0)
130 u0 = (t ^ m) - m; // |u0 - v0|
131 u0 = (u0 >> 1) >> lmmp_tailing_zeros_(t);
132 }
133 if (u0 == v0) {
134 g0 = (u0 << 1) | 1;
135 g1 = u0 >> 63;
136 } else {
137 g0 = lmmp_gcd_11_((u0 << 1) + 1, (v0 << 1) + 1);
138 g1 = 0;
139 }
140 }
141
142 dst[0] = g0;
143 dst[1] = g1;
144 if (cnt > 0)
145 lshl_u128(&dst[0], &dst[1], cnt);
146 return dst[1] == 0 ? 1 : 2;
147}
static int ctz_u128(mp_limb_t lo, mp_limb_t hi)
Copyright (C) 2026 HJimmyK (Jericho Knox)
定义 gcd_2.c:32
static void lshr_u128(mp_limb_t *lo, mp_limb_t *hi, int k)
定义 gcd_2.c:36
static void lshl_u128(mp_limb_t *lo, mp_limb_t *hi, int k)
定义 gcd_2.c:48
#define v0
#define v1
#define w0

引用了 ctz_u128(), lmmp_gcd_11_(), lmmp_gcd_22_(), lmmp_param_assert, lmmp_tailing_zeros_, lshl_u128(), lshr_u128(), t, v0, v1 , 以及 w0.

被这些函数引用 lmmp_divexact_(), lmmp_gcd_(), lmmp_gcd_22_(), lmmp_gcd_2_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_gcd_2_()

mp_size_t lmmp_gcd_2_ ( mp_ptr dst,
mp_srcptr up,
mp_size_t un,
mp_srcptr vp )

计算两个无符号整数的最大公约数

参数
up第一个无符号整数指针
un第一个无符号整数的 limb 长度
vp第二个无符号整数指针,长度为 2
dst结果指针(长度至少为 2,两个 limb 都会进行写入,即使最高位可能为0)
警告
up!=NULL, un>2, vp!=NULL, vp[1]!=0, dst!=NULL, eqsep(dst,[up|vp])
返回
dst 的实际 limb 长度

在文件 gcd_2.c 第 149 行定义.

149 {
150 lmmp_param_assert(dst != NULL);
151 lmmp_param_assert(up != NULL);
152 lmmp_param_assert(vp != NULL);
153 lmmp_param_assert(un > 2);
154 lmmp_param_assert(vp[1] != 0);
155 mp_limb_t u[2] = {vp[0], vp[1]};
156 lmmp_mod_2_(up, un, u);
157 if (u[1] == 0 && u[0] == 0) {
158 dst[0] = vp[0];
159 dst[1] = vp[1];
160 return 2;
161 } else {
162 return lmmp_gcd_22_(dst, vp, u);
163 }
164}
void lmmp_mod_2_(mp_srcptr numa, mp_size_t na, mp_ptr numb)
双精度数取余 (除数为2个limb)
定义 div.c:215

引用了 lmmp_gcd_22_(), lmmp_gcd_2_(), lmmp_mod_2_() , 以及 lmmp_param_assert.

被这些函数引用 lmmp_divexact_(), lmmp_gcd_(), lmmp_gcd_2_(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_gcd_hgcd_()

mp_size_t lmmp_gcd_hgcd_ ( mp_ptr dst,
mp_srcptr up,
mp_size_t un,
mp_srcptr vp,
mp_size_t vn )

计算两个无符号整数的最大公约数(hgcd 分治,长输入优选)

参数
dst结果指针(长度至少为 bn)
up第一个无符号整数数组(长度为 un 个limb)
un第一个无符号整数的 limb 长度
vp第二个无符号整数数组(长度为 vn 个limb)
vn第二个无符号整数的 limb 长度
警告
up!=NULL, un>=vn>0, vp!=NULL, dst!=NULL, eqsep(dst,[up|vp]), up[un-1]!=0, vp[vn-1]!=0
返回
dst 的实际 limb 长度
注解
不平衡输入(un >= 2*vn)先做取模预归约将两数长度拉近,再进入 分治主路径:不平衡时 hgcd 的阶段 A 递归失效,预归约普遍更快 (越悬殊收益越大,见 hgcd.c 实现注)

在文件 hgcd.c 第 1217 行定义.

1217 {
1218 lmmp_param_assert(dst != NULL && ap != NULL && bp != NULL);
1219 lmmp_param_assert(an >= bn && bn > 0);
1220
1221 /*
1222 不平衡预归约:当 bn <= an/2 时,b 的高半(bp[an/2,an))全零,hgcd 阶段 A
1223 的递归无法触发,数对逐层退化为"全除 + 部分除"两次 O(M(n)) 除法步进;
1224 先做一次取模将规模直接降至 b,再在平衡形状上运行分治。余数 r < b,
1225 若 r 仍显著短于 b(比例 <= 1/2)则继续取模,问题规模每轮几何递减。
1226 */
1227 mp_ptr pre0 = NULL, pre1 = NULL;
1228 if (an >= 2 * bn) {
1229 pre0 = ALLOC_TYPE(bn + 1, mp_limb_t);
1230 pre1 = ALLOC_TYPE(bn + 1, mp_limb_t);
1231 mp_srcptr up = ap, vp = bp;
1232 mp_size_t un = an, vn = bn;
1233 while (un >= 2 * vn) {
1234 mp_ptr rp = (vp == pre0) ? pre1 : pre0; /* 余数写入与除数分离的缓冲 */
1235 lmmp_div_(NULL, rp, up, un, vp, vn);
1236 mp_size_t rn = vn;
1237 while (rn > 0 && rp[rn - 1] == 0) {
1238 --rn;
1239 }
1240 if (rn == 0) { /* vp 整除 up:gcd 即 vp */
1241 lmmp_copy(dst, vp, vn);
1242 lmmp_free(pre0);
1243 lmmp_free(pre1);
1244 return vn;
1245 }
1246 up = vp;
1247 un = vn;
1248 vp = rp;
1249 vn = rn;
1250 }
1251 ap = up; /* vp 可能指向 pre0/pre1 内部,复制进工作副本后方可释放 */
1252 an = un;
1253 bp = vp;
1254 bn = vn;
1255 }
1256
1257 mp_size_t cap = an;
1258 mp_ptr wbuf = ALLOC_TYPE(cap * 2, mp_limb_t);
1259 mp_ptr wa = wbuf;
1260 mp_ptr wb = wbuf + cap;
1261 lmmp_copy(wa, ap, an);
1262 lmmp_copy(wb, bp, bn);
1263 lmmp_zero(wb + bn, cap - bn);
1264 if (pre0 != NULL) {
1265 lmmp_free(pre0);
1266 lmmp_free(pre1);
1267 }
1268
1269 mp_size_t rn;
1270 int cmp = lmmp_cmp_(wa, wb, cap);
1271 if (cmp == 0) {
1272 rn = an; /* wa 为归一化输入 ap 的副本,真实长度即 an */
1273 lmmp_copy(dst, wa, rn);
1274 lmmp_free(wbuf);
1275 return rn;
1276 } else if (cmp < 0) {
1277 LMMP_SWAP(wa, wb, mp_ptr);
1278 }
1279
1280 /* 一次性分配:scratch 与顶层矩阵缓冲,循环内复用(矩阵容量按最大 cur) */
1282 mp_ptr scbuf = ALLOC_TYPE(scsz, mp_limb_t);
1283 lmmp_hgcd_scratch_t sc = {scbuf, scsz, 0};
1284 mp_ptr mbuf = ALLOC_TYPE(4 * (an + 2), mp_limb_t);
1285
1286 mp_size_t cur = an;
1287 for (;;) {
1288 if (cur <= HGCD_RECURSE_THRESHOLD) {
1289 break;
1290 }
1292 lmmp_hgcd_matrix_init_buf_(&M, mbuf, cur + 2);
1293 int dtop = 1;
1294 mp_size_t nn = lmmp_hgcd_core_(&M, wa, wb, cur, &sc, &dtop, 0);
1295 if (nn == 0 || nn >= cur) {
1296 break; /* 无归约(防御性) */
1297 }
1298 /* [nn,cur) 为无效残留:循环内所有读写均以返回长度为界 */
1299 cur = nn;
1300 if (lmmp_zero_q_(wb, cur)) {
1301 break; /* b 归约为 0:gcd = a(存在性检查) */
1302 }
1303 if (lmmp_cmp_(wa, wb, cur) < 0) {
1304 LMMP_SWAP(wa, wb, mp_ptr); /* 指针交换 */
1305 }
1306 }
1307
1308 lmmp_free(scbuf);
1309 lmmp_free(mbuf);
1310
1311 mp_size_t ra = lmmp_gcd_norm_(wa, cur);
1312 mp_size_t rb = lmmp_gcd_norm_(wb, cur);
1313 if (rb == 0) {
1314 rn = ra;
1315 lmmp_copy(dst, wa, ra);
1316 } else {
1317 rn = lmmp_gcd_lehmer_(dst, wa, ra, wb, rb);
1318 }
1319 lmmp_free(wbuf);
1320 return rn;
1321}
mp_size_t lmmp_hgcd_scratch_size_(mp_size_t n)
计算 hgcd 内部临时空间大小(容量上界推导见 hgcd.c 定义处注)
定义 hgcd.c:162
mp_size_t lmmp_hgcd_core_(lmmp_hgcd_matrix_t *M, mp_ptr ap, mp_ptr bp, mp_size_t n, lmmp_hgcd_scratch_t *sc, int *detsign, int appr)
hgcd 递归核:将数对归约至约 n/2 规模并累积变换矩阵(详见 hgcd.c 实现注)
static mp_size_t lmmp_gcd_norm_(mp_srcptr p, mp_size_t n)
定义 gcd.h:49
#define HGCD_RECURSE_THRESHOLD
Copyright (C) 2026 HJimmyK (Jericho Knox)
定义 gcd.h:33
#define an
#define bn
static void lmmp_hgcd_matrix_init_buf_(lmmp_hgcd_matrix_t *M, mp_ptr buf, mp_size_t alloc)
将连续缓冲初始化为单位矩阵
定义 hgcd.c:500
void lmmp_free(void *ptr)
内存释放函数(调用lmmp_heap_free_fn)
int lmmp_zero_q_(mp_srcptr p, mp_size_t n)
判零函数
定义 cmp.c:55
void lmmp_div_(mp_ptr dstq, mp_ptr dstr, mp_srcptr numa, mp_size_t na, mp_srcptr numb, mp_size_t nb)
除法和取模操作
定义 div.c:85
hgcd 变换矩阵
#define ALLOC_TYPE(n, type)

引用了 ALLOC_TYPE, an, bn, HGCD_RECURSE_THRESHOLD, lmmp_cmp_(), lmmp_copy, lmmp_div_(), lmmp_free(), lmmp_gcd_hgcd_(), lmmp_gcd_lehmer_(), lmmp_gcd_norm_(), lmmp_hgcd_core_(), lmmp_hgcd_matrix_init_buf_(), lmmp_hgcd_scratch_size_(), lmmp_param_assert, LMMP_SWAP, lmmp_zero, lmmp_zero_q_() , 以及 rp.

被这些函数引用 bench_gcd_hgcd(), lmmp_gcd_(), lmmp_gcd_hgcd_(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_gcd_lehmer_()

mp_size_t lmmp_gcd_lehmer_ ( mp_ptr dst,
mp_srcptr up,
mp_size_t un,
mp_srcptr vp,
mp_size_t vn )

计算两个无符号整数的最大公约数(Lehmer算法)

参数
dst结果指针(长度至少为 min(un,vn))
up第一个无符号整数指针
un第一个无符号整数的 limb 长度
vp第二个无符号整数指针
vn第二个无符号整数的 limb 长度
警告
up!=NULL, un>0, vp!=NULL, vn>0, eqsep(dst,[up|vp]), dst!=NULL, up[un-1]!=0, vp[vn-1]!=0
返回
dst 的实际 limb 长度

在文件 gcd_lehmer.c 第 159 行定义.

159 {
160 lmmp_param_assert(un > 0 && vn > 0);
161 lmmp_param_assert(up != NULL && vp != NULL);
162 lmmp_param_assert(dst != NULL);
163
164 lmmp_param_assert(up[un - 1] != 0);
165 lmmp_param_assert(vp[vn - 1] != 0);
166
167 if (un < vn) {
168 LMMP_SWAP(up, vp, mp_srcptr);
169 LMMP_SWAP(un, vn, mp_size_t);
170 } else if (un == vn) {
171 int cmp = lmmp_cmp_(up, vp, un);
172 if (cmp == 0) {
173 lmmp_copy(dst, up, un);
174 return un;
175 } else if (cmp < 0) {
176 LMMP_SWAP(up, vp, mp_srcptr);
177 }
178 }
179 // u > v
180
182 slong x = 0, y = 0;
183
184#define an un
185#define bn vn
187 // [a,an+1] [b,bn+1]
188 // A * a_old may overlow
189 mp_ptr a = BALLOC_TYPE(an + 1, mp_limb_t);
190 mp_ptr b = BALLOC_TYPE(bn + 1, mp_limb_t);
192 mp_ptr temp = BALLOC_TYPE((an + 1) * 3, mp_limb_t);
193 ms.tp = temp;
194 ms.mp = temp + (an + 1);
195 ms.np = temp + (an + 1) * 2;
196
197 lmmp_copy(a, up, an);
198 lmmp_copy(b, vp, bn);
199
200 bool bzero = false;
201 while (bzero == false) {
202 if (an > 1 && bn == 1) {
203 dst[0] = lmmp_gcd_1_(a, an, b[0]);
205 return 1;
206 } else if (an == 1 && bn == 1) {
207 dst[0] = lmmp_gcd_11_(a[0], b[0]);
209 return 1;
210 }
211 // a > b
212 lmmp_gcd_lehmer_extract_(a, an, b, bn, &x, &y);
213 lmmp_gcd_lehmer_step_(x, y, &M);
214
215 if (M.m21 == 0) {
216 lmmp_div_(NULL, dst, a, an, b, bn);
217 lmmp_copy(a, b, bn);
218 an = bn;
219 while (bn > 0 && dst[bn - 1] == 0) {
220 --bn;
221 }
222 if (bn == 0)
223 bzero = true;
224 else
225 lmmp_copy(b, dst, bn);
226 } else {
227 bzero = lmmp_lehmer_mul_(a, &an, b, &bn, &M, &ms);
228 if ((an < bn) || (an == bn && lmmp_cmp_(a, b, an) < 0)) {
229 LMMP_SWAP(a, b, mp_ptr);
231 }
232 }
233 }
234 lmmp_copy(dst, a, an);
236 return an;
237#undef an
238#undef bn
239}
static void lmmp_gcd_lehmer_step_(slong u, slong v, lmmp_gcd_lehmer_t *M)
定义 gcd.h:113
static void lmmp_gcd_lehmer_extract_(mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn, slong *restrict a, slong *restrict b)
定义 gcd.h:142
static bool lmmp_lehmer_mul_(mp_ptr a, mp_size_t *an, mp_ptr b, mp_size_t *bn, lmmp_gcd_lehmer_t *M, lehmer_stack_t *ms)
/ a \ = / A B \ * / a \ \ b / \ C D / \ b /
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define TEMP_B_DECL
#define BALLOC_TYPE(n, type)
#define TEMP_B_FREE

引用了 an, BALLOC_TYPE, bn, lmmp_cmp_(), lmmp_copy, lmmp_div_(), lmmp_gcd_11_(), lmmp_gcd_1_(), lmmp_gcd_lehmer_(), lmmp_gcd_lehmer_extract_(), lmmp_gcd_lehmer_step_(), lmmp_lehmer_mul_(), lmmp_param_assert, LMMP_SWAP, lmmp_gcd_lehmer_t::m21, lehmer_stack_t::mp, lehmer_stack_t::np, TEMP_B_DECL, TEMP_B_FREE , 以及 lehmer_stack_t::tp.

被这些函数引用 bench_gcd_lehmer(), lmmp_divexact_(), lmmp_gcd_(), lmmp_gcd_hgcd_(), lmmp_gcd_lehmer_(), run_gcdext_pair(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_gcdext_()

mp_size_t lmmp_gcdext_ ( mp_ptr dstg,
mp_ptr dsts,
mp_ssize_t * sn,
mp_ptr dstt,
mp_ssize_t * tn,
mp_srcptr up,
mp_size_t un,
mp_srcptr vp,
mp_size_t vn )

扩展欧几里得(通用分发入口):g = gcd(u,v),s*u + t*v = g

参数
dstg结果指针(长度至少为 min(un,vn))
dstsu 的贝祖系数幅度(长度至少为 vn 个limb)
sn输出 s 的带符号 limb 长度
dsttv 的贝祖系数幅度(长度至少为 un 个limb,可为 NULL)
tn输出 t 的带符号 limb 长度(dstt==NULL 时忽略)
up第一个无符号整数指针
un第一个无符号整数的 limb 长度
vp第二个无符号整数指针
vn第二个无符号整数的 limb 长度
警告
up!=NULL, un>0, vp!=NULL, vn>0, dstg!=NULL, dsts!=NULL, sn!=NULL, up[un-1]!=0, vp[vn-1]!=0, sep([dsts|dstt],dstg)
返回
g 的实际 limb 长度
注解
vn==1 转 lmmp_gcdext_1_、vn==2(un>2)转 lmmp_gcdext_2_,两侧均 超过 GCD_HGCD_THRESHOLD 转 lmmp_gcdext_hgcd_(分治),否则 lmmp_gcdext_lehmer_。dstg 允许与 [up|vp] 别名

在文件 gcdext.c 第 692 行定义.

693 {
694 lmmp_param_assert(un > 0 && vn > 0);
695 lmmp_param_assert(up != NULL && vp != NULL && dstg != NULL && dsts != NULL && sn != NULL);
696 lmmp_param_assert(up[un - 1] != 0 && vp[vn - 1] != 0);
697
698 if (vn == 1)
699 return lmmp_gcdext_1_(dstg, dsts, sn, dstt, tn, up, un, vp[0]);
700 if (vn == 2 && un > 2)
701 return lmmp_gcdext_2_(dstg, dsts, sn, dstt, tn, up, un, vp);
702 if (vn >= GCD_HGCD_THRESHOLD && un >= GCD_HGCD_THRESHOLD)
703 return lmmp_gcdext_hgcd_(dstg, dsts, sn, dstt, tn, up, un, vp, vn);
704 return lmmp_gcdext_lehmer_(dstg, dsts, sn, dstt, tn, up, un, vp, vn);
705}
mp_size_t lmmp_gcdext_2_(mp_ptr dstg, mp_ptr dsts, mp_ssize_t *sn, mp_ptr dstt, mp_ssize_t *tn, mp_srcptr up, mp_size_t un, mp_srcptr vp)
扩展欧几里得(任意长度对双 limb):g = gcd([up,un],[vp,2]),s*u + t*v = g
mp_size_t lmmp_gcdext_1_(mp_ptr dstg, mp_ptr dsts, mp_ssize_t *sn, mp_ptr dstt, mp_ssize_t *tn, mp_srcptr up, mp_size_t un, ulong v)
扩展欧几里得(任意长度对单 limb):g = gcd([up,un],v),s*u + t*v = g
mp_size_t lmmp_gcdext_hgcd_(mp_ptr dstg, mp_ptr dsts, mp_ssize_t *sn, mp_ptr dstt, mp_ssize_t *tn, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
扩展欧几里得(hgcd 分治,长输入优选):g = gcd(u,v),s*u + t*v = g
mp_size_t lmmp_gcdext_lehmer_(mp_ptr dstg, mp_ptr dsts, mp_ssize_t *sn, mp_ptr dstt, mp_ssize_t *tn, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
扩展欧几里得(Lehmer 算法):g = gcd(u,v),s*u + t*v = g

引用了 GCD_HGCD_THRESHOLD, lmmp_gcdext_(), lmmp_gcdext_1_(), lmmp_gcdext_2_(), lmmp_gcdext_hgcd_(), lmmp_gcdext_lehmer_() , 以及 lmmp_param_assert.

被这些函数引用 lmmp_gcdext_(), lmmp_modinv_(), run_gcdext_pair(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_gcdext_11_()

ulong lmmp_gcdext_11_ ( ulong u,
ulong v,
slong * s,
slong * t )

扩展欧几里得(双 limb 标量):g = gcd(u,v),s*u + t*v = g

Copyright (C) 2026 HJimmyK (Jericho Knox)

参数
u第一个无符号整数
v第二个无符号整数
s输出 u 的贝祖系数(带符号)
t输出 v 的贝祖系数(带符号,可为 NULL 表示不需要)
警告
u!=0, v!=0, s!=NULL
返回
最大公约数 g
注解
取极小系数:|s| <= v/(2g)、|t| <= u/(2g)(由此唯一)。v|u 时 s=0、t=1

扩展欧几里得(双 limb 标量):g = gcd(u,v),s*u + t*v = g

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

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

48 {
49 lmmp_param_assert(u > 0 && v > 0);
50 lmmp_param_assert(s != NULL);
51
52 int sw = 0;
53 if (u < v) {
54 LMMP_SWAP(u, v, ulong);
55 sw = 1;
56 }
57 // u >= v
58
59 ulong r1 = u % v;
60 if (r1 == 0) {
61 // v | u:g = v,系数在较小者
62 *s = sw ? 1 : 0;
63 if (t != NULL)
64 *t = sw ? 0 : 1;
65 return v;
66 }
67
68 ulong r0 = v;
69 ulong su0 = 0, su1 = 1; // u 系数幅度(符号交替,su1 当前为正)
70 ulong tv0 = 1, tv1 = u / v; // v 系数幅度(与 su 相位相反)
71 int phase = 1; // su1 的符号 [+1|-1]
72 for (;;) {
73 ulong q = r0 / r1;
74 ulong r2 = r0 % r1;
75 if (r2 == 0)
76 break; // g = r1,系数即 (su1, tv1) 当前行
77 ulong su2 = q * su1 + su0;
78 ulong tv2 = q * tv1 + tv0;
79 r0 = r1;
80 r1 = r2;
81 su0 = su1;
82 su1 = su2;
83 tv0 = tv1;
84 tv1 = tv2;
85 phase = -phase;
86 }
87 slong gu = phase > 0 ? (slong)su1 : -(slong)su1;
88 slong gv = phase > 0 ? -(slong)tv1 : (slong)tv1;
89 *s = sw ? gv : gu;
90 if (t != NULL)
91 *t = sw ? gu : gv;
92 return r1;
93}
#define r2
#define r1
#define r0

引用了 lmmp_gcdext_11_(), lmmp_param_assert, LMMP_SWAP, r0, r1, r2, s , 以及 t.

被这些函数引用 lmmp_gcdext_11_(), lmmp_gcdext_1_(), lmmp_modinv_ulong_() , 以及 TEST_CASE().

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

◆ lmmp_gcdext_1_()

mp_size_t lmmp_gcdext_1_ ( mp_ptr dstg,
mp_ptr dsts,
mp_ssize_t * sn,
mp_ptr dstt,
mp_ssize_t * tn,
mp_srcptr up,
mp_size_t un,
ulong v )

扩展欧几里得(任意长度对单 limb):g = gcd([up,un],v),s*u + t*v = g

参数
dstg结果指针(长度为 1 个limb)
dstsu 的贝祖系数幅度(长度为 1 个limb,s==0 时写 0)
sn输出 s 的带符号 limb 长度([1|-1|0])
dsttv 的贝祖系数幅度(长度至少为 un 个limb,可为 NULL 表示不需要)
tn输出 t 的带符号 limb 长度(dstt==NULL 时忽略,可为 NULL)
up第一个无符号整数指针
un第一个无符号整数的 limb 长度
v第二个无符号整数(单 limb)
警告
up!=NULL, un>0, v!=0, dstg!=NULL, dsts!=NULL, sn!=NULL, sep([dsts|dstt],dstg)
返回
g 的 limb 长度(恒 1)
注解
取极小系数 |s| <= v/(2g)(单 limb)、|t| <= u/(2g)。v|[up,un] 时 s=0、t=1。 dstg 允许与 up 别名(eqsep);dsts/dstt 在 up 的所有读取完成后才写入

在文件 gcdext_1.c 第 95 行定义.

96 {
97 lmmp_param_assert(un > 0 && v > 0);
98 lmmp_param_assert(up != NULL && dstg != NULL && dsts != NULL && sn != NULL);
99
100 ulong r = lmmp_mod_1_(up, un, v);
101 if (r == 0) {
102 dstg[0] = v;
103 dsts[0] = 0;
104 *sn = 0;
105 if (dstt != NULL) {
106 dstt[0] = 1;
107 *tn = 1;
108 }
109 return 1;
110 }
111
112 slong sg;
113 ulong g = lmmp_gcdext_11_(r, v, &sg, NULL);
114 lmmp_debug_assert(sg != 0); // r>0 且 v∤r → g<v → σ≠0
115
116 if (dstt == NULL) {
117 dstg[0] = g;
118 dsts[0] = sg < 0 ? (ulong)-sg : (ulong)sg;
119 *sn = sg < 0 ? -1 : 1; /* 带符号长度(sg!=0 已断言) */
120 return 1;
121 }
122
123 /* t = (g - sg*u)/v:X = |sg|*u;N = g - sg*u(符号-幅度,X >= u >= g
124 保证 sg>0 时差非负方向确定);|t| = N/v。对 up 的读取(X)先于全部
125 输出写入(允许 dstg/dsts/dstt 与 up 别名的契约次序) */
127 mp_ptr x = BALLOC_TYPE(un + 2, mp_limb_t);
128 mp_ptr nb = BALLOC_TYPE(un + 2, mp_limb_t);
129 mp_ptr tq = BALLOC_TYPE(un + 2, mp_limb_t);
130 ulong sm = sg < 0 ? (ulong)-sg : (ulong)sg;
131 mp_limb_t c = lmmp_mul_1_(x, up, un, sm);
132 mp_size_t xn = un;
133 if (c != 0)
134 x[xn++] = c;
135 mp_size_t nn;
136 int tneg = 0;
137 if (sg > 0) {
138 // N = g - X = -(X - g),X >= g(|sg|>=1 且 g|u)
139 lmmp_sub_(nb, x, xn, &g, 1);
140 nn = xn;
141 while (nn > 0 && nb[nn - 1] == 0)
142 --nn;
143 tneg = nn != 0;
144 } else {
145 // N = g + X > 0
146 mp_limb_t cy = lmmp_add_(nb, x, xn, &g, 1);
147 nn = xn;
148 if (cy != 0)
149 nb[nn++] = cy;
150 }
151 // |t| = N/v(恒等式保证整除;N==0 即 t==0 时跳过除法)
152 mp_size_t tqn = 0;
153 if (nn != 0) {
154 mp_limb_t vv[1] = {v};
155 lmmp_div_(tq, NULL, nb, nn, vv, 1);
156 tqn = nn;
157 while (tqn > 0 && tq[tqn - 1] == 0)
158 --tqn;
159 }
160
161 dstg[0] = g;
162 dsts[0] = sm;
163 *sn = sg < 0 ? -1 : 1;
164 lmmp_copy(dstt, tq, tqn);
165 if (tqn == 0)
166 dstt[0] = 0;
167 *tn = tneg ? -(mp_ssize_t)tqn : (mp_ssize_t)tqn;
169 return 1;
170}
int64_t mp_ssize_t
定义 lmmp.h:95
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]
ulong lmmp_gcdext_11_(ulong u, ulong v, slong *s, slong *t)
扩展欧几里得(双 limb 标量):g = gcd(u,v),s*u + t*v = g

引用了 BALLOC_TYPE, lmmp_add_(), lmmp_copy, lmmp_debug_assert, lmmp_div_(), lmmp_gcdext_11_(), lmmp_gcdext_1_(), lmmp_mod_1_(), lmmp_mul_1_(), lmmp_param_assert, lmmp_sub_(), TEMP_B_DECL, TEMP_B_FREE , 以及 xn.

被这些函数引用 lmmp_gcdext_(), lmmp_gcdext_1_(), lmmp_gcdext_lehmer_() , 以及 TEST_CASE().

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

◆ lmmp_gcdext_2_()

mp_size_t lmmp_gcdext_2_ ( mp_ptr dstg,
mp_ptr dsts,
mp_ssize_t * sn,
mp_ptr dstt,
mp_ssize_t * tn,
mp_srcptr up,
mp_size_t un,
mp_srcptr vp )

扩展欧几里得(任意长度对双 limb):g = gcd([up,un],[vp,2]),s*u + t*v = g

Copyright (C) 2026 HJimmyK (Jericho Knox)

参数
dstg结果指针(长度至少为 2 个limb)
dstsu 的贝祖系数幅度(长度至少为 2 个limb,s==0 时写 0)
sn输出 s 的带符号 limb 长度
dsttv 的贝祖系数幅度(长度至少为 un 个limb,可为 NULL)
tn输出 t 的带符号 limb 长度(dstt==NULL 时忽略)
up第一个无符号整数指针
un第一个无符号整数的 limb 长度
vp第二个无符号整数指针(长度为 2)
警告
up!=NULL, un>2, vp!=NULL, vp[1]!=0, dstg!=NULL, dsts!=NULL, sn!=NULL, sep([dsts|dstt],dstg)
返回
g 的实际 limb 长度
注解
取极小系数(同 lmmp_gcdext_11_ 注)。经 lmmp_mod_2_ 预归约后转 lmmp_gcdext_lehmer_(无独立 2x2 核)。dstg 允许与 [up|vp] 别名

扩展欧几里得(任意长度对双 limb):g = gcd([up,un],[vp,2]),s*u + t*v = g

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

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

41 {
42 lmmp_param_assert(un > 2);
43 lmmp_param_assert(up != NULL && vp != NULL && dstg != NULL && dsts != NULL && sn != NULL);
44 lmmp_param_assert(vp[1] != 0);
45
46 mp_limb_t r[2] = {vp[0], vp[1]};
47 lmmp_mod_2_(up, un, r);
48 if (r[0] == 0 && r[1] == 0) {
49 // v | u:g = v,s = 0、t = 1
50 lmmp_copy(dstg, vp, 2);
51 dsts[0] = 0;
52 *sn = 0;
53 if (dstt != NULL) {
54 dstt[0] = 1;
55 *tn = 1;
56 }
57 return 2;
58 }
59 mp_size_t rn = (r[1] != 0) ? 2 : 1;
60
61 if (dstt == NULL)
62 return lmmp_gcdext_lehmer_(dstg, dsts, sn, NULL, NULL, r, rn, vp, 2);
63
67 mp_ptr x = BALLOC_TYPE(un + 2, mp_limb_t);
68 mp_ptr nb = BALLOC_TYPE(un + 2, mp_limb_t);
69 mp_ptr tq = BALLOC_TYPE(un + 2, mp_limb_t);
70 mp_ssize_t snn;
71 mp_size_t gn = lmmp_gcdext_lehmer_(gb, sb, &snn, NULL, NULL, r, rn, vp, 2);
72 mp_size_t snabs = snn < 0 ? -snn : snn;
73 lmmp_debug_assert(snabs > 0 && snabs <= 2); // r>0 且 v∤r → s≠0,|s| <= v/(2g) <= 2 limb
74
75 /* t = (g - s*u)/v:X = |s|*u;s>0 时 N = -(X-g)(X >= u > g),s<0 时 N = X+g */
76 if (snabs >= un)
77 lmmp_mul_(x, sb, snabs, up, un);
78 else
79 lmmp_mul_(x, up, un, sb, snabs);
80 mp_size_t xn = snabs + un;
81 while (xn > 0 && x[xn - 1] == 0)
82 --xn;
83 mp_size_t nn;
84 int tneg = 0;
85 if (snn > 0) {
86 lmmp_sub_(nb, x, xn, gb, gn);
87 nn = xn;
88 while (nn > 0 && nb[nn - 1] == 0)
89 --nn;
90 tneg = nn != 0;
91 } else {
92 mp_limb_t cy = lmmp_add_(nb, x, xn, gb, gn);
93 nn = xn;
94 if (cy != 0)
95 nb[nn++] = cy;
96 }
97 mp_size_t tqn = 0;
98 if (nn != 0) {
99 lmmp_div_(tq, NULL, nb, nn, vp, 2);
100 /* 商至多 nn-2+1 个limb(div 契约),高位未写区域不可读 */
101 tqn = nn - 1;
102 while (tqn > 0 && tq[tqn - 1] == 0)
103 --tqn;
104 }
105
106 lmmp_copy(dstg, gb, gn);
107 lmmp_copy(dsts, sb, snabs);
108 *sn = snn;
109 lmmp_copy(dstt, tq, tqn);
110 if (tqn == 0)
111 dstt[0] = 0;
112 *tn = tneg ? -(mp_ssize_t)tqn : (mp_ssize_t)tqn;
114 return gn;
115}

引用了 BALLOC_TYPE, lmmp_add_(), lmmp_copy, lmmp_debug_assert, lmmp_div_(), lmmp_gcdext_2_(), lmmp_gcdext_lehmer_(), lmmp_mod_2_(), lmmp_mul_(), lmmp_param_assert, lmmp_sub_(), TEMP_B_DECL, TEMP_B_FREE , 以及 xn.

被这些函数引用 lmmp_gcdext_(), lmmp_gcdext_2_() , 以及 TEST_CASE().

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

◆ lmmp_gcdext_hgcd_()

mp_size_t lmmp_gcdext_hgcd_ ( mp_ptr dstg,
mp_ptr dsts,
mp_ssize_t * sn,
mp_ptr dstt,
mp_ssize_t * tn,
mp_srcptr up,
mp_size_t un,
mp_srcptr vp,
mp_size_t vn )

扩展欧几里得(hgcd 分治,长输入优选):g = gcd(u,v),s*u + t*v = g

参数
dstg结果指针(长度至少为 min(un,vn))
dstsu 的贝祖系数幅度(长度至少为 vn 个limb,s==0 时写 0)
sn输出 s 的带符号 limb 长度([1|-1|0])
dsttv 的贝祖系数幅度(长度至少为 un 个limb,可为 NULL)
tn输出 t 的带符号 limb 长度(dstt==NULL 时忽略)
up第一个无符号整数指针
un第一个无符号整数的 limb 长度
vp第二个无符号整数指针
vn第二个无符号整数的 limb 长度
警告
up!=NULL, un>0, vp!=NULL, vn>0, dstg!=NULL, dsts!=NULL, sn!=NULL, up[un-1]!=0, vp[vn-1]!=0, sep([dsts|dstt],dstg)
返回
g 的实际 limb 长度
注解
取极小系数(同 lmmp_gcdext_11_ 注)。un/vn 任意大小关系(内部值序 归一化,系数按原参数序输出)。GMP mpn_gcdext 结构:初始一次取模 (商丢弃,共因子无损),主循环对高位片调库内 hgcd 核 + 低位修补, 单行 (u0,u1) 共因子跟踪(V = u0*a + u1*b,每轮 4 次行乘),降至 阈值下转 lmmp_gcdext_lehmer_;t 在输出相位经恒等式导出。 dstg 允许与 [up|vp] 别名(eqsep)

在文件 gcdext.c 第 344 行定义.

346 {
347 lmmp_param_assert(un > 0 && vn > 0);
348 lmmp_param_assert(up != NULL && vp != NULL && dstg != NULL && dsts != NULL && sn != NULL);
349 lmmp_param_assert(up[un - 1] != 0 && vp[vn - 1] != 0);
350
351 /* 值序归一化(sw 记录交换;s 恒为原始 up 的系数) */
352 int sw = 0;
353 if (un < vn) {
354 LMMP_SWAP(up, vp, mp_srcptr);
355 LMMP_SWAP(un, vn, mp_size_t);
356 sw = 1;
357 } else if (un == vn) {
358 int c = lmmp_cmp_(up, vp, un);
359 if (c == 0) {
360 lmmp_copy(dstg, up, un);
361 dsts[0] = 0;
362 *sn = 0;
363 if (dstt != NULL) {
364 dstt[0] = 1;
365 *tn = 1;
366 }
367 return un;
368 }
369 if (c < 0) {
370 LMMP_SWAP(up, vp, mp_srcptr);
371 sw = 1;
372 }
373 }
374 // U > V > 0(un >= vn),up/vp 为值序大/小者
375
376 mp_size_t n0 = un;
377 /* 一次分配:数对/修补对/矩阵/行/scratch/S/导出与尾组合暂存 */
378 mp_size_t mcap = 2 * n0 / 3 + 4; /* M1 每元素容量(p >= n/3 时片长 <= 2n/3) */
379 mp_size_t scsz = lmmp_hgcd_scratch_size_(2 * n0 / 3 + 2) + 4 * n0 + 64;
380 mp_size_t wsz = (n0 + 1) * 4 /* wa/wb/sa/sb */
381 + 4 * mcap /* M1 矩阵(尾段 gb 复用) */
382 + (n0 + 2) * 2 /* 行 u0/u1 */
383 + scsz /* hgcd scratch 池 */
384 + (n0 + 2) /* S 暂存 */
385 + (2 * n0 + 4) * 2 /* 导出 nb/yt */
386 + (2 * n0 + 8) * 2; /* 尾组合积 p1/p2 */
387 mp_ptr wbuf = ALLOC_TYPE(wsz, mp_limb_t);
388 mp_ptr wa = wbuf;
389 mp_ptr wb = wbuf + (n0 + 1);
390 mp_ptr sa = wbuf + 2 * (n0 + 1);
391 mp_ptr sb = wbuf + 3 * (n0 + 1);
392 mp_ptr mbuf1 = wbuf + 4 * (n0 + 1);
393 mp_ptr u0p = mbuf1 + 4 * mcap;
394 mp_ptr u1p = u0p + (n0 + 2);
395 mp_ptr scbuf = u1p + (n0 + 2);
396 mp_ptr sp = scbuf + scsz; /* S 暂存 */
397 mp_ptr nb = sp + (n0 + 2);
398 mp_ptr yt = nb + (2 * n0 + 4);
399 mp_ptr p1b = yt + (2 * n0 + 4); /* 尾组合积 sigma*u1 */
400 mp_ptr p2b = p1b + (2 * n0 + 8); /* 尾组合积 tau*u0 */
401 lmmp_hgcd_scratch_t sc = {scbuf, scsz, 0};
402
403 /* 初始归约:U 长于 V 时一次除法(商丢弃——q 乘零行元素无需计算) */
404 mp_size_t n;
405 int rowz = 0; /* 初始归约后行为 (1,0)(首轮捷径取 M1 第 0 行、det 反号) */
406 if (un > vn) {
407 lmmp_div_(NULL, wb, up, un, vp, vn); /* a = U mod V 直写 wb(<= vn limbs) */
408 mp_size_t rn = lmmp_gcd_norm_(wb, vn);
409 if (rn == 0) {
410 /* V | U:g = V,系数 (S,T) = (0,1),按 sw 映射 */
411 lmmp_copy(dstg, vp, vn);
412 if (!sw) {
413 dsts[0] = 0;
414 *sn = 0;
415 if (dstt != NULL) {
416 dstt[0] = 1;
417 *tn = 1;
418 }
419 } else {
420 dsts[0] = 1;
421 *sn = 1;
422 if (dstt != NULL) {
423 dstt[0] = 0;
424 *tn = 0;
425 }
426 }
427 lmmp_free(wbuf);
428 return vn;
429 }
430 lmmp_copy(wa, vp, vn);
431 lmmp_zero(wb + rn, vn - rn);
432 n = vn;
433 rowz = 1; /* 归约已发生:行 (1,0)、det=-1(E_div 行 1) */
434 } else {
435 lmmp_copy(wa, up, un);
436 lmmp_copy(wb, vp, vn);
437 n = un;
438 }
439
440 /*
441 行 (u0,u1):未经归约时初值 (0,1)(V = 0*U + 1*V);初始归约后为
442 (1,0)(V = 1*V + 0*r,E_div = /q 1;1 0/ 的行 1,det=-1)。首轮 hgcd
443 成功后直接取 M1 的对应行((0,1)*M1 = 行1、(1,0)*M1 = 行0),免一次行乘
444 */
445 mp_size_t u0n = 0, u1n = 0;
446 int det = 1;
447 if (rowz) {
448 u0p[0] = 1;
449 u0n = 1;
450 det = -1;
451 } else {
452 u1p[0] = 1;
453 u1n = 1;
454 }
455 int rowinit = 0; /* 行是否已经历首轮 M1 初始化 */
456 int first = 1;
457 int term_g0 = 0; /* (g;0) 终态(g 在 wa,长度 n) */
458 while (n > HGCD_RECURSE_THRESHOLD) {
459 /*
460 失衡守卫(与 lmmp_gcd_hgcd_ 的预归约同策略):b 归一化后不足公共长
461 的一半时,core 的高位片 (wa+p; wb+p) 中 b 部分全零,递归内部违反
462 a>b>0 前提——直接走除法步把 a 归约到 b 规模再平衡
463 */
464 mp_size_t nb_cur = lmmp_gcd_norm_(wb, n);
465 int degenerate = (2 * nb_cur <= n);
466 mp_size_t p = first ? n / 2 : n / 3;
467 mp_size_t nn = 0;
469 int dsub = 1;
470 if (!degenerate) {
471 first = 0;
472 lmmp_gcd_matrix_init_buf_(&M1, mbuf1, n - p + 2);
473 sc.used = 0;
474 nn = lmmp_hgcd_core_(&M1, wa + p, wb + p, n - p, &sc, &dsub, 0);
475 }
476 if (nn > 0) {
477 sc.used = 0;
478 mp_size_t blen = 0;
479 mp_size_t rn = lmmp_hgcd_adjust_(&M1, dsub, sa, sb, &blen, wa + p, wb + p, nn, wa, wb,
480 n, p, &sc);
481 sc.used = 0;
483 if (rn > 0 && rn < n && blen > maxlen) {
484 lmmp_copy(wa, sa, rn);
485 lmmp_copy(wb, sb, rn);
486 if (lmmp_cmp_(wa, wb, rn) < 0) {
487 LMMP_SWAP(wa, wb, mp_ptr); /* 指针交换后基址偏离 wbuf,仅长度域内使用 */
489 dsub = -dsub;
490 }
491 if (!rowinit) {
492 /* 行 <- M1 对应行((0,1)*M1 = 行1;归约后 (1,0)*M1 = 行0),
493 M1 缓冲下一轮被重初始化,须拷出 */
494 int rr = rowz ? 0 : 1;
495 lmmp_copy(u0p, M1.m[rr][0], M1.n[rr][0]);
496 u0n = M1.n[rr][0];
497 lmmp_copy(u1p, M1.m[rr][1], M1.n[rr][1]);
498 u1n = M1.n[rr][1];
499 det = rowz ? -dsub : dsub; /* E_div 的 det=-1 已并入 */
500 rowinit = 1;
501 } else {
502 gcdext_row_mul_(u0p, u1p, &u0n, &u1n, &M1, &sc);
503 det *= dsub;
504 }
505 n = rn;
506 continue;
507 }
508 }
509 /*
510 core 失败或修补被拒:除法步。core 失败多为近邻对(商 1)——先做
511 一次减法 r = a - b,行为纯加(原位 addmul+对调);r >= b 时商 >= 2,
512 做一次除法 a = q*b + r(商标量走原位 addmul,多 limb 走全乘)。
513 行 <- (q*u0 + u1, u0),detsign 变号;余数为 0 即终态 (g;0)
514 */
515 {
516 mp_size_t mark = sc.used;
517 /* 试减 r1 = a - b(a > b 无借位;r1 < b ⟺ 商为 1) */
518 lmmp_sub_(sa, wa, n, wb, nb_cur);
519 mp_size_t r1n = lmmp_gcd_norm_(sa, n);
520 if (r1n < nb_cur || (r1n == nb_cur && lmmp_cmp_(sa, wb, r1n) < 0)) {
521 /* 商为 1(含 r1 == 0 终态):数对 (b; r1) */
522 gcdext_row_qscalar_(&u0p, &u1p, &u0n, &u1n, 1);
523 det = -det;
524 rowinit = 1;
525 sc.used = mark;
526 if (r1n == 0) {
527 LMMP_SWAP(wa, wb, mp_ptr); /* g = wb(除数),移入 wa 统一终态 */
528 n = nb_cur;
529 term_g0 = 1;
530 break;
531 }
532 lmmp_copy(wa, wb, nb_cur);
533 lmmp_zero(wa + nb_cur, n - nb_cur);
534 lmmp_copy(wb, sa, r1n);
535 lmmp_zero(wb + r1n, nb_cur - r1n);
536 n = nb_cur;
537 continue;
538 }
539 /* 商 >= 2:全除法 a = q*b + r,余数直写 sa(eqsep 契约) */
540 mp_ptr q = lmmp_hgcd_salloc_(&sc, n + 2);
541 lmmp_div_(q, sa, wa, n, wb, nb_cur);
542 mp_size_t qn = n - nb_cur + 1 - (q[n - nb_cur] == 0);
543 mp_size_t rn = lmmp_gcd_norm_(sa, nb_cur);
544 if (qn == 1 && q[0] < (1ull << 63)) {
545 /* 商为标量:行原位 addmul + 对调 */
546 gcdext_row_qscalar_(&u0p, &u1p, &u0n, &u1n, q[0]);
547 } else if (u0n == 0) {
548 /* u0 为零:new_u0 = u1,new_u1 = 0(指针对调即可) */
549 LMMP_SWAP(u0p, u1p, mp_ptr);
550 LMMP_SWAP(u0n, u1n, mp_size_t);
551 } else {
552 /* 多 limb 商:new_u0 = q*u0 + u1(积 <= V/g <= n0+1 limb) */
553 mp_ptr t1 = lmmp_hgcd_salloc_(&sc, qn + u0n + 2);
554 lmmp_gcd_mul_(t1, q, qn, u0p, u0n);
555 mp_size_t pn = qn + u0n;
556 while (pn > 0 && t1[pn - 1] == 0)
557 --pn;
558 mp_ptr r0 = lmmp_hgcd_salloc_(&sc, n0 + 2);
559 mp_size_t r0n = 0;
560 if (u1n == 0) {
561 lmmp_copy(r0, t1, pn);
562 r0n = pn;
563 } else {
564 mp_limb_t c = (pn >= u1n) ? lmmp_add_(r0, t1, pn, u1p, u1n)
565 : lmmp_add_(r0, u1p, u1n, t1, pn);
566 r0n = pn > u1n ? pn : u1n;
567 if (c != 0)
568 r0[r0n++] = c;
569 }
570 lmmp_copy(u1p, u0p, u0n); /* new_u1 = 旧 u0 */
571 u1n = u0n;
572 lmmp_copy(u0p, r0, r0n);
573 u0n = r0n;
574 }
575 rowinit = 1;
576 det = -det;
577 sc.used = mark;
578 if (rn == 0) {
579 /* g = wb(除数),移入 wa 统一终态 */
580 LMMP_SWAP(wa, wb, mp_ptr);
581 n = nb_cur;
582 term_g0 = 1;
583 break;
584 }
585 /* 数对 (b; r):b 入 wa,r(sa)入 wb,公共长 nb_cur */
586 lmmp_copy(wa, wb, nb_cur);
587 lmmp_zero(wa + nb_cur, n - nb_cur);
588 lmmp_copy(wb, sa, rn);
589 lmmp_zero(wb + rn, nb_cur - rn);
590 n = nb_cur;
591 }
592 }
593
594 /* ---------------- 尾段与发射 ---------------- */
595 mp_size_t gn = 0;
596 mp_size_t sun = 0; /* S(值序大者系数)幅度长 */
597 int suneg = 0;
598 if (term_g0) {
599 gn = n;
600 sun = gcdext_pick_s_(sp, &suneg, u0p, u0n, u1p, u1n, det, sa);
601 lmmp_gcdext_emit_(dstg, dsts, sn, dstt, tn, wa, gn, sp, sun, suneg, sw, up, un, vp, vn, nb,
602 yt, p1b);
603 } else {
604 /* Lehmer 尾:当前对 (wa,wb) 取极小系数 (sigma,tau),
605 S = det*(sigma*u1 - tau*u0)(两次乘 + 符号-幅度组合) */
606 mp_size_t ra = lmmp_gcd_norm_(wa, n);
607 mp_size_t rb = lmmp_gcd_norm_(wb, n);
608 mp_ptr gb = mbuf1; /* <= n <= 64 limb(循环已降至阈值下),mcap 足够 */
609 mp_ptr sgp = sa;
610 mp_ptr taup = sb;
611 mp_ssize_t snp, tnp;
612 gn = lmmp_gcdext_lehmer_(gb, sgp, &snp, taup, &tnp, wa, ra, wb, rb);
613 mp_size_t snabs = snp < 0 ? -snp : snp;
614 mp_size_t tnabs = tnp < 0 ? -tnp : tnp;
615 mp_size_t p1n = 0, p2n = 0;
616 if (snabs != 0 && u1n != 0) {
617 lmmp_gcd_mul_(p1b, sgp, snabs, u1p, u1n);
618 p1n = snabs + u1n;
619 while (p1n > 0 && p1b[p1n - 1] == 0)
620 --p1n;
621 }
622 if (tnabs != 0 && u0n != 0) {
623 lmmp_gcd_mul_(p2b, taup, tnabs, u0p, u0n);
624 p2n = tnabs + u0n;
625 while (p2n > 0 && p2b[p2n - 1] == 0)
626 --p2n;
627 }
628 /* S = sigma*u1 + (-tau)*u0(第二项符号 = τ 取负),符号-幅度组合 */
629 lmmp_gcdext_smag_(sp, &sun, &suneg, p1b, p1n, snp < 0, p2b, p2n, !(tnp < 0));
630 if (det < 0 && sun != 0)
631 suneg = !suneg;
632 /*
633 极小化:S 落在正确的格类(det*(sigma*m11-tau*m10) ≡ S_true (mod V/g)),
634 但可能偏离极小代表元至多若干步(|K| <= V/(2g)*(1+o(1)),步数有界)。
635 快测 2*g*|S| <= V(⟺ |S| <= D/2,D = V/g):一次 sn*gn 乘 + 比较,
636 多数输入直接通过,免算 D 的整除;未过时按 D 向 0 平移至 |S| <= D/2;
637 平局(2|S| == D)恒取正(该侧配对系数满足 |t| <= U/(2g),另一侧
638 |g + D*U/2| > D*U/2 必越界)
639 */
640 if (sun != 0) {
641 lmmp_gcd_mul_(p1b, sp, sun, gb, gn); /* |S|*g */
642 mp_size_t pn = sun + gn;
643 while (pn > 0 && p1b[pn - 1] == 0)
644 --pn;
645 mp_limb_t c2 = lmmp_mul_1_(p2b, p1b, pn, 2); /* 2*|S|*g */
646 mp_size_t twon = pn + (c2 != 0);
647 int cmp2 = (twon != vn) ? (twon < vn ? -1 : 1) : lmmp_cmp_(p2b, vp, vn);
648 if (cmp2 > 0) {
649 mp_ptr db = p1b; /* D = V/g(恒等式保证整除,商长度 vn-gn+1) */
650 lmmp_div_(db, NULL, vp, vn, gb, gn);
651 mp_size_t dnn = vn - gn + 1;
652 while (dnn > 0 && db[dnn - 1] == 0)
653 --dnn;
654 for (;;) {
655 mp_limb_t c2s = lmmp_mul_1_(p2b, sp, sun, 2);
656 mp_size_t twosn = sun + (c2s != 0);
657 int cmp2s = (twosn != dnn) ? (twosn < dnn ? -1 : 1) : lmmp_cmp_(p2b, db, dnn);
658 if (cmp2s < 0)
659 break;
660 if (cmp2s == 0) {
661 suneg = 0; /* 平局恒取正 */
662 break;
663 }
664 int cD = (sun != dnn) ? (sun < dnn ? -1 : 1) : lmmp_cmp_(sp, db, dnn);
665 if (cD >= 0) {
666 lmmp_sub_(sp, sp, sun, db, dnn);
667 while (sun > 0 && sp[sun - 1] == 0)
668 --sun;
669 } else {
670 lmmp_sub_(sp, db, dnn, sp, sun);
671 sun = dnn;
672 while (sun > 0 && sp[sun - 1] == 0)
673 --sun;
674 suneg = !suneg;
675 }
676 if (sun == 0) {
677 suneg = 0;
678 break;
679 }
680 }
681 } else if (cmp2 == 0) {
682 suneg = 0; /* 平局恒取正 */
683 }
684 }
685 lmmp_gcdext_emit_(dstg, dsts, sn, dstt, tn, gb, gn, sp, sun, suneg, sw, up, un, vp, vn, nb,
686 yt, p1b);
687 }
688 lmmp_free(wbuf);
689 return gn;
690}
static void lmmp_gcdext_smag_(mp_ptr dst, mp_size_t *n, int *neg, mp_srcptr x, mp_size_t xn, int xneg, mp_srcptr y, mp_size_t yn, int yneg)
定义 gcd.h:169
mp_size_t lmmp_hgcd_adjust_(lmmp_hgcd_matrix_t *M1, int detsign, mp_ptr dap, mp_ptr dbp, mp_size_t *blen, mp_srcptr ha, mp_srcptr hb, mp_size_t hn0, mp_srcptr ap, mp_srcptr bp, mp_size_t n, mp_size_t p, lmmp_hgcd_scratch_t *sc)
高位直写 + 低位修补:将子递归成果(矩阵 M1 与归约后的高位对)合入完整数对
定义 hgcd.c:554
static mp_ptr lmmp_hgcd_salloc_(lmmp_hgcd_scratch_t *sc, mp_size_t n)
定义 gcd.h:42
static mp_size_t lmmp_gcd_matrix_maxlen_(const lmmp_hgcd_matrix_t *M)
定义 gcd.h:56
static void lmmp_gcd_mul_(mp_ptr dst, mp_srcptr a, mp_size_t an, mp_srcptr b, mp_size_t bn)
定义 gcd.h:92
void lmmp_gcdext_emit_(mp_ptr dstg, mp_ptr dsts, mp_ssize_t *sn, mp_ptr dstt, mp_ssize_t *tn, mp_srcptr gp, mp_size_t gn, mp_srcptr sp, mp_size_t sun, int suneg, int sw, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn, mp_ptr nb, mp_ptr yt, mp_ptr qt)
发射:g 与 S(值序大者系数)按 sw 映射到 (dsts,dstt),另一系数经恒等式导出
static void lmmp_gcd_matrix_init_buf_(lmmp_hgcd_matrix_t *M, mp_ptr buf, mp_size_t alloc)
定义 gcd.h:77
static void lmmp_gcd_matrix_swap_cols_(lmmp_hgcd_matrix_t *M)
定义 gcd.h:70
static mp_size_t gcdext_pick_s_(mp_ptr sp, int *sneg, mp_srcptr u0p, mp_size_t u0n, mp_srcptr u1p, mp_size_t u1n, int det, mp_ptr t1)
static void gcdext_row_qscalar_(mp_ptr *u0p, mp_ptr *u1p, mp_size_t *u0n, mp_size_t *u1n, ulong q)
Copyright (C) 2026 HJimmyK (Jericho Knox)
static void gcdext_row_mul_(mp_ptr u0p, mp_ptr u1p, mp_size_t *u0n, mp_size_t *u1n, const lmmp_hgcd_matrix_t *M1, lmmp_hgcd_scratch_t *sc)
#define M1

引用了 ALLOC_TYPE, gcdext_pick_s_(), gcdext_row_mul_(), gcdext_row_qscalar_(), HGCD_RECURSE_THRESHOLD, lmmp_add_(), lmmp_cmp_(), lmmp_copy, lmmp_div_(), lmmp_free(), lmmp_gcd_matrix_init_buf_(), lmmp_gcd_matrix_maxlen_(), lmmp_gcd_matrix_swap_cols_(), lmmp_gcd_mul_(), lmmp_gcd_norm_(), lmmp_gcdext_emit_(), lmmp_gcdext_hgcd_(), lmmp_gcdext_lehmer_(), lmmp_gcdext_smag_(), lmmp_hgcd_adjust_(), lmmp_hgcd_core_(), lmmp_hgcd_salloc_(), lmmp_hgcd_scratch_size_(), lmmp_mul_1_(), lmmp_param_assert, lmmp_sub_(), LMMP_SWAP, lmmp_zero, M1, n , 以及 r0.

被这些函数引用 lmmp_gcdext_() , 以及 lmmp_gcdext_hgcd_().

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

◆ lmmp_gcdext_lehmer_()

mp_size_t lmmp_gcdext_lehmer_ ( mp_ptr dstg,
mp_ptr dsts,
mp_ssize_t * sn,
mp_ptr dstt,
mp_ssize_t * tn,
mp_srcptr up,
mp_size_t un,
mp_srcptr vp,
mp_size_t vn )

扩展欧几里得(Lehmer 算法):g = gcd(u,v),s*u + t*v = g

参数
dstg结果指针(长度至少为 min(un,vn))
dstsu 的贝祖系数幅度(长度至少为 vn 个limb,s==0 时写 0)
sn输出 s 的带符号 limb 长度([1|-1|0])
dsttv 的贝祖系数幅度(长度至少为 un 个limb,可为 NULL 表示不需要)
tn输出 t 的带符号 limb 长度(dstt==NULL 时忽略,可为 NULL)
up第一个无符号整数指针
un第一个无符号整数的 limb 长度
vp第二个无符号整数指针
vn第二个无符号整数的 limb 长度
警告
up!=NULL, un>0, vp!=NULL, vn>0, dstg!=NULL, dsts!=NULL, sn!=NULL, up[un-1]!=0, vp[vn-1]!=0, sep([dsts|dstt],dstg)
返回
g 的实际 limb 长度
注解
取极小系数(同 lmmp_gcdext_11_ 注)。un/vn 任意大小关系(内部值序 归一化,系数按原参数序输出)。归约骨架与 gcd_lehmer.c 同构,共因子 走单行跟踪(GMP 行向量思想):全程保持 V = u0*a + u1*b(行元素非负, a;b 为当前数对),t 在输出相位经恒等式导出(dstt==NULL 时跳过)。 dstg 允许与 [up|vp] 别名(eqsep);dsts/dstt 在 up/vp 的所有读取 完成后才写入

在文件 gcdext_lehmer.c 第 209 行定义.

211 {
212 lmmp_param_assert(un > 0 && vn > 0);
213 lmmp_param_assert(up != NULL && vp != NULL && dstg != NULL && dsts != NULL && sn != NULL);
214 lmmp_param_assert(up[un - 1] != 0 && vp[vn - 1] != 0);
215
216 /* 值序归一化(sw 记录交换;s 恒为值序大者的系数,输出时按 sw 映射回原参数序) */
217 int sw = 0;
218 if (un < vn) {
219 LMMP_SWAP(up, vp, mp_srcptr);
220 LMMP_SWAP(un, vn, mp_size_t);
221 sw = 1;
222 } else if (un == vn) {
223 int c = lmmp_cmp_(up, vp, un);
224 if (c == 0) {
225 lmmp_copy(dstg, up, un);
226 dsts[0] = 0;
227 *sn = 0;
228 if (dstt != NULL) {
229 dstt[0] = 1;
230 *tn = 1;
231 }
232 return un;
233 }
234 if (c < 0) {
235 LMMP_SWAP(up, vp, mp_srcptr);
236 sw = 1;
237 }
238 }
239 // U > V > 0(un >= vn,up/vp 为值序大/小者)
240
241 mp_size_t RSZ = un + 2;
243 mp_ptr buf = BALLOC_TYPE(10 * RSZ + (2 * un + 8) + 3 * (un + 2) + 2, mp_limb_t);
244 mp_ptr pool = buf; /* 数对池 4 槽,各 RSZ */
245 mp_ptr rowp = pool + 4 * RSZ; /* 行槽 4(u0/u1/k0/k1),各 RSZ */
246 mp_ptr t1 = rowp + 4 * RSZ; /* 终态 2*u1 与尾合并组合临时 */
247 mp_ptr t2 = t1 + RSZ;
248 mp_ptr t2f = t2 + RSZ; /* 全乘积缓冲(除法步行积/尾合并 τ·u0/发射 nb) */
249 mp_ptr qt = t2f + (2 * un + 8);
250 mp_ptr rt = qt + (un + 2);
251 mp_ptr tg = rt + (un + 2); /* 尾合并 g(1)+ σ(1)+ τ/S 暂存(un+2) */
252 mp_ptr ts = tg + 1;
253 mp_ptr tt = ts + 1;
254
255 sco_t u0 = {rowp, 0, 0}, u1 = {rowp + RSZ, 0, 0};
256 sco_t k0 = {rowp + 2 * RSZ, 0, 0}, k1 = {rowp + 3 * RSZ, 0, 0};
257 u1.n = 1;
258 u1.p[0] = 1; /* V = 0*a + 1*b */
259 int det = 1;
260
261 int ia = 0, ib = 1;
262 mp_ptr a = pool;
263 mp_ptr b = pool + RSZ;
264 mp_size_t an = un, bn = vn;
265 lmmp_copy(a, up, un);
266 lmmp_copy(b, vp, vn);
267
268 mp_size_t sun = 0; /* S(值序大者系数)幅度长 */
269 int suneg = 0;
270 mp_ptr sp = tt; /* S 幅度暂存(<= vn+1 <= un+2) */
271 mp_ptr gp = NULL; /* g 暂存 */
272 mp_size_t gn = 0;
274 slong x = 0, y = 0;
275 for (;;) {
276 if (bn == 0) {
277 /*
278 (g;0) 终态:V = u0*g(强制 u0 > 0),解间隔 u0 = V/g,候选
279 det*u1 + k*u0 取距 0 近者(平局恒取正候选 +|u1|,见文件注三)
280 */
281 gp = a;
282 gn = an;
283 lmmp_debug_assert(u0.neg == 0); /* V = u0*g 与 V>0 强制 */
284 if (u1.n == 0) {
285 sun = 0;
286 suneg = 0;
287 } else {
288 mp_limb_t c2 = lmmp_mul_1_(t1, u1.p, u1.n, 2);
289 mp_size_t twon = u1.n + (c2 != 0);
290 int cmp2 = mag_cmp_(t1, twon, u0.p, u0.n);
291 int sn1 = (u1.neg != 0) ^ (det < 0); /* S0 = det*u1 的符号 */
292 if (cmp2 < 0) {
293 lmmp_copy(sp, u1.p, u1.n);
294 sun = u1.n;
295 suneg = sn1;
296 } else if (cmp2 > 0) {
297 /* S = S0 - sign(S0)*u0:幅度 u0-|u1| (< u0/2),符号翻转 */
298 lmmp_sub_(sp, u0.p, u0.n, u1.p, u1.n);
299 sun = u0.n;
300 while (sun > 0 && sp[sun - 1] == 0)
301 --sun;
302 suneg = sun != 0 && !sn1;
303 } else {
304 lmmp_copy(sp, u1.p, u1.n); /* 平局恒取正候选 */
305 sun = u1.n;
306 suneg = 0;
307 }
308 }
309 break;
310 }
311 if (bn == 1) {
312 /* 尾合并:g = sigma*a + tau*b(lmmp_gcdext_1_ 极小系数),
313 s = det*(sigma*u1 - tau*u0):一次标量乘 + 一次全乘 + 符号-幅度组合 */
314 mp_ssize_t sgn, tgn;
315 lmmp_gcdext_1_(tg, ts, &sgn, tt, &tgn, a, an, b[0]);
316 lmmp_debug_assert(tg[0] != 0);
317 gp = tg;
318 gn = 1;
319 slong sigma = sgn < 0 ? -(slong)ts[0] : (slong)ts[0];
320 mp_size_t tqn = tgn < 0 ? -tgn : tgn;
321 mp_size_t p1n = 0, p2n = 0;
322 int p1neg = 0, p2neg = 0;
323 if (sigma != 0 && u1.n != 0) {
324 mp_limb_t c = lmmp_mul_1_(k0.p, u1.p, u1.n,
325 sigma < 0 ? (ulong)-sigma : (ulong)sigma);
326 p1n = u1.n;
327 if (c != 0)
328 k0.p[p1n++] = c;
329 p1neg = (sigma < 0) ^ (u1.neg != 0);
330 }
331 if (tqn != 0 && u0.n != 0) {
332 if (tqn >= u0.n)
333 lmmp_mul_(t2f, tt, tqn, u0.p, u0.n);
334 else
335 lmmp_mul_(t2f, u0.p, u0.n, tt, tqn);
336 p2n = tqn + u0.n;
337 while (p2n > 0 && t2f[p2n - 1] == 0)
338 --p2n;
339 p2neg = (tgn < 0) ^ (u0.neg != 0);
340 }
341 /* s = sigma*u1 - tau*u0 = p1 + (-p2)(第二项符号翻转) */
342 lmmp_gcdext_smag_(t1, &sun, &suneg, k0.p, p1n, p1neg, t2f, p2n, !p2neg);
343 lmmp_copy(sp, t1, sun);
344 if (det < 0 && sun != 0)
345 suneg = !suneg;
346 break;
347 }
348
349 lmmp_gcd_lehmer_extract_(a, an, b, bn, &x, &y);
350 lmmp_gcd_lehmer_step_(x, y, &M);
351 if (M.m21 == 0) {
352 /*
353 除法回退:a = q*b + r,数对 (b;r)。行 <- 行*E:(q*u0+u1, u0),
354 det 变号。余数直写旧 a 槽(eqsep 契约),数对槽位交换即可
355 */
356 lmmp_div_(qt, a, a, an, b, bn);
357 mp_size_t qn = an - bn + 1 - (qt[an - bn] == 0);
358 mp_size_t rn = bn;
359 while (rn > 0 && a[rn - 1] == 0)
360 --rn;
361 if (qn == 1 && qt[0] < (1ull << 63)) {
362 /* 商为标量:行更新走 lc1_(两遍扫描快路) */
363 int d0 = u0.neg ? -1 : 1, d1 = u1.neg ? -1 : 1;
364 lc1_(&k0, (slong)qt[0] * d0, u0.p, u0.n, d1, u1.p, u1.n);
365 } else {
366 mp_size_t pn = 0;
367 if (qn != 0 && u0.n != 0) {
368 if (qn >= u0.n)
369 lmmp_mul_(t2f, qt, qn, u0.p, u0.n);
370 else
371 lmmp_mul_(t2f, u0.p, u0.n, qt, qn);
372 pn = qn + u0.n;
373 while (pn > 0 && t2f[pn - 1] == 0)
374 --pn;
375 }
376 lmmp_gcdext_smag_(k0.p, &k0.n, &k0.neg, t2f, pn, u0.neg != 0, u1.p, u1.n,
377 u1.neg != 0);
378 }
379 {
380 sco_t t_ = u1;
381 u1 = u0;
382 u0 = k0;
383 k0 = t_;
384 }
385 mp_ptr ta = a;
386 a = b;
387 b = ta; /* b 槽现持有 r */
388 an = bn;
389 bn = rn;
390 int ti = ia;
391 ia = ib;
392 ib = ti;
393 det = -det;
394 continue;
395 }
396 /*
397 矩阵步:值 (new_a;new_b) = (C*a+D*b; A*a+B*b) 落入两空闲槽;
398 行 <- 行*N_applied^{-1},四组合系数 X(见文件注二)为带符号标量
399 */
400 int f1, f2;
401 pool_free2_(ia, ib, &f1, &f2);
402 sco_t sa = {pool + f1 * RSZ, 0, 0}, sb = {pool + f2 * RSZ, 0, 0};
403 lc1_(&sa, M.m21, a, an, M.m22, b, bn);
404 lc1_(&sb, M.m11, a, an, M.m12, b, bn);
405 lmmp_debug_assert(sa.n != 0 || sb.n != 0);
406 int da = sa.neg ? -1 : 1, db = sb.neg ? -1 : 1;
407 slong dlin = M.m21 * M.m12 - M.m22 * M.m11; /* det_lin = C*B - D*A = ±1 */
408 slong sda = (slong)da * dlin, sdb = (slong)db * dlin;
409 /* 行元素带符号:符号折入组合标量(sda、d0 均为 ±1,|标量| = |矩阵元素| < 2^31) */
410 int d0 = u0.neg ? -1 : 1, d1 = u1.neg ? -1 : 1;
411 lc1_(&k0, sda * M.m12 * d0, u0.p, u0.n, -sda * M.m11 * d1, u1.p, u1.n);
412 lc1_(&k1, -sdb * M.m22 * d0, u0.p, u0.n, sdb * M.m21 * d1, u1.p, u1.n);
413 det = (int)(det * da * db * dlin);
414 {
415 sco_t t_ = u0;
416 u0 = k0;
417 k0 = t_;
418 }
419 {
420 sco_t t_ = u1;
421 u1 = k1;
422 k1 = t_;
423 }
424 /* 数对新槽与值序(值序翻转 = 行分量对调 + det 变号) */
425 if (sa.n == 0) {
426 sco_t t_ = u0;
427 u0 = u1;
428 u1 = t_;
429 det = -det;
430 a = pool + f2 * RSZ;
431 an = sb.n;
432 b = pool + f1 * RSZ;
433 bn = 0;
434 ia = f2;
435 ib = f1;
436 } else if (sb.n == 0) {
437 a = pool + f1 * RSZ;
438 an = sa.n;
439 b = pool + f2 * RSZ;
440 bn = 0;
441 ia = f1;
442 ib = f2;
443 } else if (mag_cmp_(sa.p, sa.n, sb.p, sb.n) < 0) {
444 sco_t t_ = u0;
445 u0 = u1;
446 u1 = t_;
447 det = -det;
448 a = pool + f2 * RSZ;
449 an = sb.n;
450 b = pool + f1 * RSZ;
451 bn = sa.n;
452 ia = f2;
453 ib = f1;
454 } else {
455 a = pool + f1 * RSZ;
456 an = sa.n;
457 b = pool + f2 * RSZ;
458 bn = sb.n;
459 ia = f1;
460 ib = f2;
461 }
462 }
463
464 /* 发射:g 与 S 按 sw 映射 + 恒等式导出(与 hgcd 驱动共享,见 impl/gcd.h) */
465 /* qt 复用 k1 行槽(容量 RSZ=un+2,循环已结束槽位死亡) */
466 lmmp_gcdext_emit_(dstg, dsts, sn, dstt, tn, gp, gn, sp, sun, suneg, sw, up, un, vp, vn, t2f, rt,
467 k1.p);
469 return gn;
470}
static void pool_free2_(int ia, int ib, int *f1, int *f2)
static int mag_cmp_(mp_srcptr x, mp_size_t xn, mp_srcptr y, mp_size_t yn)
mp_size_t n
static void lc1_(sco_t *dst, slong al, mp_srcptr x, mp_size_t xn, slong be, mp_srcptr y, mp_size_t yn)
dst = al*x + be*y(x,y 为非负幅度;al,be 为带符号标量,|al|,|be| < 2^63)
Copyright (C) 2026 HJimmyK (Jericho Knox)

引用了 an, BALLOC_TYPE, bn, lc1_(), lmmp_cmp_(), lmmp_copy, lmmp_debug_assert, lmmp_div_(), lmmp_gcd_lehmer_extract_(), lmmp_gcd_lehmer_step_(), lmmp_gcdext_1_(), lmmp_gcdext_emit_(), lmmp_gcdext_lehmer_(), lmmp_gcdext_smag_(), lmmp_mul_(), lmmp_mul_1_(), lmmp_param_assert, lmmp_sub_(), LMMP_SWAP, lmmp_gcd_lehmer_t::m11, lmmp_gcd_lehmer_t::m12, lmmp_gcd_lehmer_t::m21, lmmp_gcd_lehmer_t::m22, mag_cmp_(), sco_t::n, sco_t::neg, sco_t::p, pool_free2_(), TEMP_B_DECL , 以及 TEMP_B_FREE.

被这些函数引用 lmmp_gcdext_(), lmmp_gcdext_2_(), lmmp_gcdext_hgcd_() , 以及 lmmp_gcdext_lehmer_().

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

◆ lmmp_hgcd_()

mp_size_t lmmp_hgcd_ ( lmmp_hgcd_matrix_t * M,
mp_ptr ap,
mp_ptr bp,
mp_size_t n )

半扩展欧几里得:将数对原地归约至约一半规模,并累积变换矩阵

参数
M变换矩阵(入口应为单位矩阵,出口满足 (a;b) = M*(a';b'))
ap较大分量输入兼输出数组(长度为 n 个limb,出口保证较大者位于 ap)
bp较小分量输入兼输出数组(长度为 n 个limb,允许高位零填充)
nap,bp 的公共长度
警告
M!=NULL, ap!=NULL, bp!=NULL, sep(ap,bp), n>0, M->alloc>=n+2, ap[n-1]!=0(a 须归一化;bp 非全零,允许高位零填充),[ap,n]>[bp,n](值序)
返回
归约后公共长度(成功时一般 <= n/2+2;若归约中遇到整除完成态会提前返回, 此时 [bp,*] 可能已为 0,由调用者检查);0 表示未做任何归约(M 保持单位矩阵)
注解
gcd(a,b) = gcd(a',b')。渐进复杂度 O(M(n) log n),M 为乘法复杂度。 长输入下经由 lmmp_gcd_hgcd_ 使用;直接调用时注意 ap/bp 需要各自 n limbs 容量。

在文件 hgcd.c 第 1199 行定义.

1199 {
1200 lmmp_param_assert(M != NULL && ap != NULL && bp != NULL);
1201 lmmp_param_assert(n > 0);
1202 lmmp_debug_assert(M->alloc >= n + 2);
1203 lmmp_param_assert(ap[n - 1] != 0);
1204 if (lmmp_cmp_(ap, bp, n) <= 0) {
1205 return 0; /* a == b:gcd 即自身,无归约意义;a < b 违反契约 */
1206 }
1207 /* 一次性 scratch(与 lmmp_gcd_hgcd_ 相同的裸上界;矩阵元素缓冲由调用方提供) */
1209 mp_ptr scbuf = ALLOC_TYPE(scsz, mp_limb_t);
1210 lmmp_hgcd_scratch_t sc = {scbuf, scsz, 0};
1211 int dtop = 1;
1212 mp_size_t rn = lmmp_hgcd_core_(M, ap, bp, n, &sc, &dtop, 0);
1213 lmmp_free(scbuf);
1214 return rn;
1215}

引用了 lmmp_hgcd_matrix_t::alloc, ALLOC_TYPE, lmmp_cmp_(), lmmp_debug_assert, lmmp_free(), lmmp_hgcd_(), lmmp_hgcd_core_(), lmmp_hgcd_scratch_size_(), lmmp_param_assert , 以及 n.

被这些函数引用 lmmp_hgcd_() , 以及 TEST_CASE().

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

◆ lmmp_hgcd_matrix_free_()

void lmmp_hgcd_matrix_free_ ( lmmp_hgcd_matrix_t * M)

释放 hgcd 变换矩阵的元素缓冲

参数
M变换矩阵
警告
M!=NULL, M 须由 lmmp_hgcd_matrix_init_ 初始化且未被释放

在文件 hgcd.c 第 1188 行定义.

1188 {
1189 lmmp_param_assert(M != NULL);
1190 lmmp_free(M->m[0][0]);
1191 M->m[0][0] = NULL;
1192 M->m[0][1] = NULL;
1193 M->m[1][0] = NULL;
1194 M->m[1][1] = NULL;
1195 M->n[0][0] = M->n[0][1] = M->n[1][0] = M->n[1][1] = 0;
1196 M->alloc = 0;
1197}
mp_size_t n[2][2]

引用了 lmmp_hgcd_matrix_t::alloc, lmmp_free(), lmmp_hgcd_matrix_free_(), lmmp_param_assert, lmmp_hgcd_matrix_t::m , 以及 lmmp_hgcd_matrix_t::n.

被这些函数引用 lmmp_hgcd_matrix_free_() , 以及 TEST_CASE().

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

◆ lmmp_hgcd_matrix_init_()

void lmmp_hgcd_matrix_init_ ( lmmp_hgcd_matrix_t * M,
mp_size_t alloc )

初始化 hgcd 变换矩阵为单位矩阵(堆分配元素缓冲)

参数
M变换矩阵
alloc每元素容量(limb)。若随后用于 n limb 数对的 hgcd,需 alloc >= n+2
警告
M!=NULL, alloc>0
注解
使用完毕须调用 lmmp_hgcd_matrix_free_ 释放

在文件 hgcd.c 第 1181 行定义.

1181 {
1182 lmmp_param_assert(M != NULL);
1183 lmmp_param_assert(alloc > 0);
1184 mp_ptr buf = ALLOC_TYPE(4 * alloc, mp_limb_t);
1185 lmmp_hgcd_matrix_init_buf_(M, buf, alloc);
1186}

引用了 ALLOC_TYPE, lmmp_hgcd_matrix_init_(), lmmp_hgcd_matrix_init_buf_() , 以及 lmmp_param_assert.

被这些函数引用 lmmp_hgcd_matrix_init_() , 以及 TEST_CASE().

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

◆ lmmp_hyperfac_()

mp_size_t lmmp_hyperfac_ ( mp_ptr dst,
mp_bitcnt_t bits,
mp_size_t rn,
ushort n )

计算hyper阶乘(k^k累乘至n)

参数
dst结果指针
bitshyper阶乘的2的因子数
rn结果指针的 limb 长度
nhyper阶乘的阶数
警告
dst!=NULL, rn>0
返回
dst 的实际 limb 长度

引用了 LMMP_API, lmmp_hyperfac_() , 以及 n.

被这些函数引用 lmmp_hyperfac_(), lmmp_hyperfac_() , 以及 TEST_CASE().

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

◆ lmmp_hyperfac_size_()

mp_size_t lmmp_hyperfac_size_ ( ushort n,
mp_bitcnt_t * bits )

计算hyper阶乘的 limb 缓冲区长度

参数
nhyper阶乘的阶数
bits被修改为 hyper阶乘的2的因子数
警告
bits!=NULL
返回
hyper阶乘的 limb 缓冲区长度

引用了 LMMP_API, lmmp_hyperfac_size_() , 以及 n.

被这些函数引用 lmmp_hyperfac_size_(), lmmp_hyperfac_size_() , 以及 TEST_CASE().

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

◆ lmmp_invcbrt_newton_()

void lmmp_invcbrt_newton_ ( mp_ptr dstis,
mp_size_t ns,
mp_srcptr numa,
mp_size_t na )

计算逆立方根的定点下近似:记 I=floor(cbrt(B^(3*ns+na)/[numa,na])), 则 [dstis,ns+1] 满足 I-1 <= [dstis,ns+1] <= I,且 dstis[ns]>=1

参数
dstis目标数组(长度为 ns+1 个limb)
nsdstis数组的 limb 长度为 ns+1
numa输入数组
nanuma数组的 limb 长度
警告
ns>=3, na>0, ns>=na, numa[na-1]>=B/8 (0x2000000000000000), dstis!=NULL, numa!=NULL, sep(dstis,numa)
注解
结果是 I 的至多低估 1 的下近似,绝不高估;随机输入实测几乎恒等于 I, 仅当 I 邻近 B^ns 或 2*B^ns 的构造输入(如 [numa,na]=B^na-1、B^na/8 等)会得到 I-1。 恒有 dstis[ns]>=1,即结果落在 [B^ns, 2*B^ns] 内。 当 ns<na 时语义不同:仅使用 numa 的最高 ns 个 limb(记为 a_top), 结果变为 floor(cbrt(B^(4*ns)/a_top))-[0|1],与 I 相差 B^((ns-na)/3) 倍。

引用了 LMMP_API, lmmp_cbrt_(), lmmp_cbrt_newton_(), lmmp_invcbrt_newton_(), lmmp_mod_2p48sub1_(), lmmp_nthroot_(), lmmp_nthroot_size_(), lmmp_nthroot_ulong_(), lmmp_perfsqr_(), lmmp_perfsqr_filter_(), lmmp_perfsqr_filter_1_(), n , 以及 tp.

被这些函数引用 lmmp_cbrt_newton_(), lmmp_invcbrt_newton_(), lmmp_invcbrt_newton_() , 以及 TEST_CASE().

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

◆ lmmp_invsqrt_newton_()

void lmmp_invsqrt_newton_ ( mp_ptr dstis,
mp_size_t ns,
mp_srcptr numa,
mp_size_t na )

计算逆平方根的定点下近似:记 I=floor(sqrt(B^(2*ns+na)/[numa,na])), 则 [dstis,ns+1] 满足 I-1 <= [dstis,ns+1] <= I,且 dstis[ns]=1

参数
dstis目标数组
nsdstis数组的 limb 长度为 ns+1
numa输入数组
nanuma数组的 limb 长度
警告
ns>=3, na>0, ns>=na(否则语义变化,见
注解
), numa[na-1]>=B/4, dstis!=NULL, numa!=NULL, sep(dstis,numa)
结果是 I 的至多低估 1 的下近似,绝不高估;随机输入实测几乎恒等于 I, 仅当 I 邻近 B^ns 或 2*B^ns 的构造输入(如 [numa,na]=B^na/4、B^na-1 等) 会得到 I-1。 恒有 dstis[ns]=1,即结果落在 [B^ns, 2*B^ns) 内。 当 ns<na 时语义不同:仅使用 numa 的最高 ns 个 limb(记为 a_top), 结果变为 floor(sqrt(B^(3*ns)/a_top))-[0|1],与 I 相差 B^((ns-na)/2) 倍。

引用了 a0, a1, a2, LMMP_API, lmmp_cbrt_3_(), lmmp_cbrt_6_(), lmmp_cbrt_chebyshev_(), lmmp_cbrt_ulong_(), lmmp_invsqrt_newton_(), lmmp_sqrt_(), lmmp_sqrt_newton_() , 以及 n.

被这些函数引用 lmmp_invsqrt_newton_(), lmmp_invsqrt_newton_(), lmmp_sqrt_newton_() , 以及 TEST_CASE().

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

◆ lmmp_is_prime_2_()

int lmmp_is_prime_2_ ( mp_limb_t lo,
mp_limb_t hi )

判断 128 位素数

参数
lo待判断数的低 64 位
hi待判断数的高 64 位
警告
hi>0
注解
在 lmmp_is_prime_2_notrial_ 前进行小素数试除。适合随机输入或一般情况。
返回
0 = 合数;1 = 素数(确定性判据);2 = 极可能是素数(强 BPSW 型非确定性判据)

在文件 is_prime_2.c 第 739 行定义.

739 {
740 lmmp_param_assert(hi > 0);
741 slong i;
742
743 if ((lo & 1) == 0) return 0;
744
745#define ainv0 ll_trial_primes[i][0]
746#define ainv1 ll_trial_primes[i][1]
747#define abound0 ll_trial_primes[i][2]
748#define abound1 ll_trial_primes[i][3]
749#define binv0 ll_trial_primes[i + 1][0]
750#define binv1 ll_trial_primes[i + 1][1]
751#define bbound0 ll_trial_primes[i + 1][2]
752#define bbound1 ll_trial_primes[i + 1][3]
753
754 if (hi < FAST_TRIAL_BOUND) {
755 for (i = 0; i < 32; i += 2) {
756 u128 a = _umul128to128_(hi, lo, ainv1, ainv0);
757 u128 b = _umul128to128_(hi, lo, binv1, binv0);
758 if ((_u128high(a) < abound1) | (_u128high(b) < bbound1)) return 0;
759 }
760 } else {
761 for (i = 0; i < 32; i += 2) {
762 u128 a = _umul128to128_(hi, lo, ainv1, ainv0);
763 u128 b = _umul128to128_(hi, lo, binv1, binv0);
764 if (ll_le(a, ((u128)abound1 << 64) | abound0) | ll_le(b, ((u128)bbound1 << 64) | bbound0))
765 return 0;
766 }
767 }
768#undef ainv0
769#undef ainv1
770#undef abound0
771#undef abound1
772#undef binv0
773#undef binv1
774#undef bbound0
775#undef bbound1
776
777 return is2_notrial_i_(lo, hi);
778}
#define bbound1
#define FAST_TRIAL_BOUND
#define binv1
static int is2_notrial_i_(mp_limb_t lo, mp_limb_t hi)
#define ainv0
#define abound1
static int ll_le(u128 a, u128 b)
#define binv0
#define ainv1
#define bbound0
#define abound0
static __uint128_t _umul128to128_(uint64_t a_high, uint64_t a_low, uint64_t b_high, uint64_t b_low)

引用了 _umul128to128_(), abound0, abound1, ainv0, ainv1, bbound0, bbound1, binv0, binv1, FAST_TRIAL_BOUND, is2_notrial_i_(), ll_le(), lmmp_is_prime_2_(), lmmp_param_assert , 以及 lo.

被这些函数引用 bench_is_prime_2(), check_prime_2_agreement(), ipn_proth_i_(), lmmp_is_prime_2_(), lmmp_is_prothprime_(), lmmp_powmod_(), pool_2() , 以及 TEST_CASE().

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

◆ lmmp_is_prime_2_notrial_()

int lmmp_is_prime_2_notrial_ ( mp_limb_t lo,
mp_limb_t hi )

判断 128 位素数(无试除法)

参数
lo待判断数的低 64 位
hi待判断数的高 64 位
警告
hi>0, lo%2==1
注解
不进行试除法,对于含有明显小因子的输入不会早退。建议输入 不含小因子或强伪素数、半素数等。 B <= n < SWbound = 3317044064679887385961981(约 2^81.5)时为确定性判据(前 13 个素数基底的 Rabin-Miller, Sorenson-Webster),返回 1;更大时为 BPSW 型判据(基底 2 强伪素数 测试叠加强 Lucas-Selfridge 测试的 V 阶梯实现,Lucas 参数含 A* 脆弱区绕行((5|n)=-1 时 Q 取 1/5 的归一化形),另含 BFW vpsp 与 Q-Euler 两项强化检查,素数必然全过),学界无已知反例,返回 2。
返回
0 = 合数;1 = 素数(确定性判据);2 = 极可能是素数(强 BPSW 型非确定性判据)

在文件 is_prime_2.c 第 733 行定义.

733 {
734 lmmp_param_assert(hi > 0);
735 if ((lo & 1) == 0) return 0;
736 return is2_notrial_i_(lo, hi);
737}

引用了 is2_notrial_i_(), lmmp_is_prime_2_notrial_(), lmmp_param_assert , 以及 lo.

被这些函数引用 bench_is_prime_2_notrial(), check_prime_2_agreement(), lmmp_is_prime_2_notrial_() , 以及 lmmp_powmod_().

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

◆ lmmp_is_prime_n_()

int lmmp_is_prime_n_ ( mp_srcptr np,
mp_size_t nn,
int strength )

大整数素性检验(强度分档,大于 128 位)

参数
np待测数指针(nn 个limb)
nn待测数的 limb 长度
strength检测强度 [0,7],语义同 lmmp_is_prime_n_notrial_,强度越高理论误判率越低。 强度>=4时,已是接受集为标准 BPSW 素性(学界目前无已知反例)接受集的子集。
警告
np!=NULL, nn>2, np[nn-1]>0, 0<=strength<=7
注解
在 lmmp_is_prime_n_notrial_ 前进行小素数试除,适合随机输入或者一般情况。 建议使用强度 5 档,能够很好的平衡伪素数和素数的平均耗时。素性强度可以参照 lmmp_is_prime_n_notrial_中的说明。
返回
0 = 合数;1 = 素数(确定性判据,本契约域不可达); 2 = 极大概率为素数

在文件 is_prime_n.c 第 646 行定义.

646 {
647 lmmp_param_assert(np != NULL);
648 lmmp_param_assert(nn > 2 && np[nn - 1] > 0);
649 lmmp_param_assert(strength >= 0 && strength <= 7);
650
651 if ((np[0] & 1) == 0) return 0;
652
653 /* 小素数试除初筛:契约域 n > 2^128 大于一切表内素数,命中即合数 */
654 if (lmmp_trialdiv_(np, nn, ipn_trial_bound[strength])) return 0;
655
656 return ipn_notrial_i_(np, nn, strength);
657}
static const ushort ipn_trial_bound[8]
static int ipn_notrial_i_(mp_srcptr np, mp_size_t nn, int strength)
bool lmmp_trialdiv_(mp_srcptr np, mp_size_t nn, ushort N)
Copyright (C) 2026 HJimmyK (Jericho Knox)

引用了 ipn_notrial_i_(), ipn_trial_bound, lmmp_is_prime_n_(), lmmp_param_assert , 以及 lmmp_trialdiv_().

被这些函数引用 bench_is_prime_n(), bench_is_prime_n_proth(), ipn_proth_i_(), lmmp_is_prime_n_(), lmmp_powmod_(), pool_n(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_is_prime_n_notrial_()

int lmmp_is_prime_n_notrial_ ( mp_srcptr np,
mp_size_t nn,
int strength )

大整数素性检验(无试除法,强度分档,大于 128 位)

参数
np待测数指针(nn 个limb)
nn待测数的 limb 长度
strength检测强度 [0,7]。随机基底 MR 分两层:"1+n" 搭配指先跑至多 x 轮 1 limb 随机基底(a in [3,B) 均匀,廉价,可尽早拒判)再跑至多 y 轮 全域(n limb 随机基底,[2,n-2] 均匀)基底。各层均为“至多”轮数,任一轮检出 合数即提前终止:
强度 基底2 MR 1 limb 基底 MR n limb 基底 MR 强 Lucas
0 √ 3 2 -
1 √ 4 3 -
2 √ 5 4 -
3 √ 6 5 -
4 √ 0 0 √
5 √ 2 0 √
6 √ 3 1 √
7 √ 4 2 √
警告
np!=NULL, nn>2, np[nn-1]>0, np[0]%2==1, 0<=strength<=7
注解
1. 不进行试除法,对于含有明显小因子的输入不会早退。建议输入不含小因子或强伪素数、半素数等。
  1. 建议实际使用强度 5 档,能够很好的平衡伪素数和素数的平均耗时,对于真素数不会耗费过长的时间, 且可以更快的过滤伪素数。该档为 BPSW 型判据(基底 2 MR 叠加强 Lucas)之上增加 2 轮 1 limb 随机基底 MR;其中 Lucas 半部含 BFW vpsp 与 Q-Euler 两项强化检查 (Baillie-Fiori-Wagstaff 2021,素数必然全过),故接受集为标准 BPSW 接受集的子集 (合数只可能多拒、不可能少拒)。
  2. 强卢卡斯判据本身和 MR 测量相当正交,因此强度档大于4时,增加更多轮次 MR 测试存在边际效应, 并不能无条件的降低 BPSW 条件下的实际误判率。更多的 MR 轮次,只承担早退的任务,对于部分 伪素数可以更早的返回,而不是进行卢卡斯检验。但对于可能通过的(伪)素数,总时间反而增加。
注意
1 limb 基底空间仅 2^64,可能存在精心构造的伪素数,使其可以通过 1 limb 基底空间的所有 MR 测试。此测试主要用于搭配全基底空间快速过滤,不承诺对抗性输入下的强度保证。
返回
0 = 合数;1 = 素数(确定性判据,本契约域不可达);2 = 极大概率为素数

在文件 is_prime_n.c 第 659 行定义.

659 {
660 lmmp_param_assert(np != NULL);
661 lmmp_param_assert(nn > 2 && np[nn - 1] > 0);
662 lmmp_param_assert(strength >= 0 && strength <= 7);
663
664 if ((np[0] & 1) == 0) return 0;
665
666 return ipn_notrial_i_(np, nn, strength);
667}

引用了 ipn_notrial_i_(), lmmp_is_prime_n_notrial_() , 以及 lmmp_param_assert.

被这些函数引用 bench_is_prime_n_notrial(), lmmp_is_prime_n_notrial_(), lmmp_powmod_() , 以及 TEST_CASE().

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

◆ lmmp_is_prime_uint_()

bool lmmp_is_prime_uint_ ( uint n)

判断素数

参数
n待判断的数
返回
若 n 为素数,返回 true,否则返回 false

在文件 is_prime_uint.c 第 124 行定义.

124 {
125 if (n == 2)
126 return true;
127 if (n % 2 == 0 || n <= 1)
128 return false;
129 int judge = lmmp_is_prime_table_(n);
130 if (judge == 0) {
131 return false;
132 } else if (judge == 1) {
133 return true;
134 }
135
136 if (trial_div35711(n))
137 return false;
138
140}
bool lmmp_is_prime_uint_notrial_(uint n)
u32 档双基底强伪素数内核(基底 2 + dj_base49 哈希基底,普通域免蒙域算术)
int lmmp_is_prime_table_(uint p)
根据全局素数表判断一个数是否为素数
static int trial_div35711(ulong n)
校验是否能被3,5,7,11整除,能够整除则返回1,否则返回0

引用了 lmmp_is_prime_table_(), lmmp_is_prime_uint_(), lmmp_is_prime_uint_notrial_(), n , 以及 trial_div35711().

被这些函数引用 lmmp_is_prime_uint_(), lmmp_powmod_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_is_prime_ulong_()

bool lmmp_is_prime_ulong_ ( ulong n)

判断素数

参数
n待判断的数
返回
若 n 为素数,返回 true,否则返回 false

在文件 is_prime_ulong.c 第 345 行定义.

345 {
346 if (n == 2)
347 return true;
348 if (n % 2 == 0 || n <= 1)
349 return false;
350 if (n <= MP_UINT_MAX) {
351 int judge = lmmp_is_prime_table_(n);
352 if (judge == 0) {
353 return false;
354 } else if (judge == 1) {
355 return true;
356 }
357 }
358 if (trial_div35711(n))
359 return false;
361}
#define MP_UINT_MAX
bool lmmp_is_prime_ulong_notrial_(ulong n)
判断素数(无试除法,单 limb 档)

引用了 lmmp_is_prime_table_(), lmmp_is_prime_ulong_(), lmmp_is_prime_ulong_notrial_(), MP_UINT_MAX, n , 以及 trial_div35711().

被这些函数引用 bench_is_prime_ulong(), lmmp_is_prime_ulong_(), lmmp_is_prothprime_(), lmmp_powmod_(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_is_prime_ulong_notrial_()

bool lmmp_is_prime_ulong_notrial_ ( ulong n)

判断素数(无试除法,单 limb 档)

参数
n待判断的数(建议为极有可能为素数的数)
注解
不进行试除法过滤,适用于判断已被小素数试除法过滤的数或强伪素数
警告
n>2
返回
若 n 为素数,返回 true,否则返回 false

在文件 is_prime_ulong.c 第 257 行定义.

257 {
258 lmmp_param_assert(n > 2);
259 if (n <= MP_UINT_MAX) {
260 if (n % 2 == 0)
261 return false;
263 } else if (n < 684630005672341) {
264 ushort bases[2];
265 bases[0] = 2;
266 bases[1] = dj_base49[((0x3AC69A35UL * n) & 0xFFFFFFFFUL) >> 21] + 3;
267 if (n % bases[0] == 0)
268 return false;
269 if (n % bases[1] == 0)
270 return false;
271
272 ulong m_inv = -lmmp_binvert_ulong_(n);
273 ulong R2 = mont63_R2(n);
274 ulong one = to_mont63(1, R2, n, m_inv);
275 ulong m_1 = to_mont63(n - 1, R2, n, m_inv);
276
277 ulong d;
278 ulong t;
279 ctz_shr_u64(d, n - 1, t);
280 int eb = lmmp_limb_bits_(d);
281
282 ulong v2 = powmod2_63(d, R2, n, m_inv);
283 if (!sprp_check63(v2, t, n, m_inv, one, m_1)) return false;
284
285 ulong v;
286 powmod_win3_63(&v, to_mont63(bases[1], R2, n, m_inv), d, eb, n, m_inv);
287 return sprp_check63(v, t, n, m_inv, one, m_1);
288 } else {
289 ushort bases[3];
290 ulong bbmask = dj_base64[((0x3AC69A35UL * n) & 0xFFFFFFFFUL) >> 18];
291 bases[0] = 2;
292 bases[1] = (bbmask & 0x8000) ? 26460 : 9375;
293 bases[2] = (bbmask & 0x7FFF) + 3;
294
295 if (n % bases[0] == 0)
296 return false;
297 if (n % bases[1] == 0)
298 return false;
299 if (n % bases[2] == 0)
300 return n == bases[2];
301
302 ulong one = 1;
303 ulong m_1 = n - 1;
304 ulong m_inv = -lmmp_binvert_ulong_(n);
305
306 ulong d;
307 ulong t;
308 ctz_shr_u64(d, n - 1, t);
309 int eb = lmmp_limb_bits_(d);
310
311 if (n <= MONT63_MAX) {
312 ulong R2 = mont63_R2(n);
313 one = to_mont63(one, R2, n, m_inv);
314 m_1 = to_mont63(m_1, R2, n, m_inv);
315
316 ulong v2 = powmod2_63(d, R2, n, m_inv);
317 if (!sprp_check63(v2, t, n, m_inv, one, m_1)) return false;
318
319 /* 双基底交错 + 3 位窗口 */
320 ulong bm1 = to_mont63(bases[1], R2, n, m_inv);
321 ulong bm2 = to_mont63(bases[2], R2, n, m_inv);
322 ulong v1, v2_;
323 powmod2_win3_63(&v1, &v2_, bm1, bm2, d, eb, n, m_inv);
324 if (!sprp_check63(v1, t, n, m_inv, one, m_1)) return false;
325 return sprp_check63(v2_, t, n, m_inv, one, m_1);
326 } else {
327 ulong R2 = mont64_R2(n);
328 one = to_mont64(one, R2, n, m_inv);
329 m_1 = to_mont64(m_1, R2, n, m_inv);
330
331 ulong v2 = powmod2_64(d, R2, n, m_inv);
332 if (!sprp_check64(v2, t, n, m_inv, one, m_1)) return false;
333
334 /* 双基底交错 + 3 位窗口 */
335 ulong bm1 = to_mont64(bases[1], R2, n, m_inv);
336 ulong bm2 = to_mont64(bases[2], R2, n, m_inv);
337 ulong v1, v2_;
338 powmod2_win3_64(&v1, &v2_, bm1, bm2, d, eb, n, m_inv);
339 if (!sprp_check64(v1, t, n, m_inv, one, m_1)) return false;
340 return sprp_check64(v2_, t, n, m_inv, one, m_1);
341 }
342 }
343}
const uint16_t dj_base49[2048]
Copyright (C) 2026 HJimmyK (Jericho Knox)
const uint16_t dj_base64[16384]
static ulong mont64_R2(ulong m)
static void powmod_win3_63(ulong *pv, ulong bm, ulong d, int ebits, ulong m, ulong m_inv)
#define MONT63_MAX
Copyright (C) 2026 HJimmyK (Jericho Knox)
static ulong to_mont63(ulong x, ulong R2, ulong m, ulong m_inv)
static ulong mont63_R2(ulong m)
static ulong powmod2_63(ulong d, ulong R2, ulong m, ulong m_inv)
static int sprp_check64(ulong v, ulong t, ulong m, ulong m_inv, ulong one, ulong m_1)
static int sprp_check63(ulong v, ulong t, ulong m, ulong m_inv, ulong one, ulong m_1)
static void powmod2_win3_64(ulong *pv1, ulong *pv2, ulong bm1, ulong bm2, ulong d, int ebits, ulong m, ulong m_inv)
static void powmod2_win3_63(ulong *pv1, ulong *pv2, ulong bm1, ulong bm2, ulong d, int ebits, ulong m, ulong m_inv)
static ulong powmod2_64(ulong d, ulong R2, ulong m, ulong m_inv)
static ulong to_mont64(ulong x, ulong R2, ulong m, ulong m_inv)
#define ctz_shr_u64(r, x, cnt)
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define bm1
#define v2
uint16_t ushort
定义 numth.h:36

引用了 bm1, ctz_shr_u64, dj_base49, dj_base64, lmmp_binvert_ulong_(), lmmp_is_prime_uint_notrial_(), lmmp_is_prime_ulong_notrial_(), lmmp_limb_bits_, LMMP_NOINLINE, lmmp_param_assert, MONT63_MAX, mont63_R2(), mont64_R2(), MP_UINT_MAX, n, powmod2_63(), powmod2_64(), powmod2_win3_63(), powmod2_win3_64(), powmod_win3_63(), sprp_check63(), sprp_check64(), t, to_mont63(), to_mont64(), v1 , 以及 v2.

被这些函数引用 bench_is_prime_ulong_notrial(), lmmp_is_prime_ulong_(), lmmp_is_prime_ulong_notrial_(), lmmp_next_prime_ulong_(), lmmp_powmod_(), lmmp_prev_prime_ulong_(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_is_prothprime_()

int lmmp_is_prothprime_ ( uint k,
mp_size_t n )

Proth 数 k*2^n+1 的素性判定(普罗斯定理)

参数
k系数(k < 2^32)
n指数(2 的幂次)
警告
k>0 且为奇数, n>0
返回
0 = 合数;1 = 素数(确定性判据,本契约域可达); 2 = 极大概率为素数(BPSW 型素数;回退路径,极少触发)

在文件 is_prime_n.c 第 768 行定义.

768 {
769 lmmp_param_assert(k > 0 && n > 0);
770 lmmp_param_assert((k & 1) == 1);
771 ulong kk = k;
773 uint bk = (uint)lmmp_limb_bits_(kk);
774
775 /* N < 2^64(ne + bitlen(kk) <= 64):确定性小数路径 */
776 if (ne + bk <= 64) return lmmp_is_prime_ulong_((kk << ne) + 1) ? 1 : 0;
777
778 /* ne < 64:kk 簇低位与 limb0 的 1 共享 limb(N < 2^32*2^63 < 2^96,恰
779 双 limb),非稀疏形状——走 lmmp_is_prime_2_ 三态路径值透传
780 (<SWbound 确定性返回 1,之上 BPSW 型返回 2) */
781 if (ne < 64) {
782 u128 N = ((u128)kk << ne) + 1;
783 return lmmp_is_prime_2_((mp_limb_t)N, (mp_limb_t)(N >> 64));
784 }
785
786 /* 普罗斯定理驱动域:ne >= 64 ⟹ N >= 2^64 且 limb0 恒为纯 1(kk 簇整
787 体位于 limb >= 1,稀疏形状必命中),nn >= 2,kk < 2^32 <= 2^ne(定
788 理条件 k 奇、k < 2^t 自动成立)。装配 N = kk*2^ne + 1 */
789 mp_size_t nn = (mp_size_t)((ne + bk - 1) / LIMB_BITS) + 1;
790 TEMP_DECL;
791 mp_ptr np = TALLOC_TYPE(nn, mp_limb_t);
792 lmmp_zero(np, nn);
793 np[0] = 1;
794 mp_size_t w = (mp_size_t)(ne / LIMB_BITS);
795 mp_bitcnt_t s = ne % LIMB_BITS;
796 if (s == 0) {
797 np[w] = (mp_limb_t)kk;
798 } else {
799 np[w] |= (mp_limb_t)(kk << s);
800 mp_limb_t hi = (mp_limb_t)(kk >> (LIMB_BITS - s));
801 if (hi) np[w + 1] = hi; /* hi != 0 ⟺ 顶位跨 limb ⟺ w+1 == nn-1 */
802 }
803 int ret = ipn_proth_i_(np, nn, kk, ne);
804 TEMP_FREE;
805 return ret;
806}
static int ipn_proth_i_(mp_srcptr np, mp_size_t nn, ulong kk, mp_bitcnt_t ne)
int lmmp_is_prime_2_(mp_limb_t lo, mp_limb_t hi)
判断 128 位素数
bool lmmp_is_prime_ulong_(ulong n)
判断素数

引用了 ipn_proth_i_(), k, LIMB_BITS, lmmp_is_prime_2_(), lmmp_is_prime_ulong_(), lmmp_is_prothprime_(), lmmp_limb_bits_, lmmp_param_assert, lmmp_zero, n, s, TALLOC_TYPE, TEMP_DECL , 以及 TEMP_FREE.

被这些函数引用 bench_is_prothprime(), lmmp_is_prothprime_(), lmmp_powmod_(), pool_proth(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_is_strong_lucas_()

int lmmp_is_strong_lucas_ ( mp_srcptr np,
mp_size_t nn )

强 Lucas-Selfridge 测试(大于 128 位)

参数
np待测奇数指针(nn 个limb)
nn待测数的 limb 长度
警告
np!=NULL, nn>2, np[nn-1]>0, np[0]%2==1
注解
Selfridge 方法 A:P=1,Q=(1-D)/4,D 取 5,-7,9,-11,... 中首个 (D|n)=-1 者;V-only 阶梯实现,判据与标准 U/V 强 Lucas 测试精确一致 (U_d=0 经 P=1 恒等式 D*U_d = 2V_{d+1} - V_d 以 2V_{d+1}=V_d 检出), 判据命中后叠加 BFW vpsp(V_{n+1}=2Q)与 Q-Euler(Q^{(n+1)/2}=+-Q) 两项强化检查(Baillie-Fiori-Wagstaff 2021,素数必然全过)。 判定合数的情形含 gcd(|D|,n)>1 与 n 为完全平方数。 单轮成本约为单轮 MR 的 1.6~2 倍
返回
1 = 通过强 Lucas 测试;0 = 合数

在文件 is_prime_n.c 第 506 行定义.

506 {
507 lmmp_param_assert(np != NULL);
508 lmmp_param_assert(nn > 2 && np[nn - 1] > 0);
509 lmmp_param_assert(np[0] % 2 == 1);
510
511 TEMP_DECL;
512 lmmp_mont_t mc;
513 ipn_sdiv_t sd;
514 mp_size_t mn = lmmp_mont_need_(nn, 1);
515 mp_ptr restrict arena = TALLOC_TYPE(mn + 2 * nn, mp_limb_t);
516 lmmp_mont_init_(&mc, np, nn, arena, 1, arena + mn);
517 ipn_sdiv_init_(&sd, np, nn);
518 int ret = ipn_lucas_i_(np, nn, &mc, &sd, arena + mn);
519 lmmp_mont_free_(&mc);
520 TEMP_FREE;
521 return ret;
522}
static void ipn_sdiv_init_(ipn_sdiv_t *sd, mp_srcptr np, mp_size_t nn)
短除上下文初始化:归一化除数顶 2 limb 与其 2/1 逆元
static int ipn_lucas_i_(mp_srcptr np, mp_size_t nn, lmmp_mont_t *restrict mc, const ipn_sdiv_t *sd, mp_ptr restrict prod)
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define restrict
Copyright (C) 2026 HJimmyK (Jericho Knox)

引用了 ipn_lucas_i_(), ipn_sdiv_init_(), lmmp_is_strong_lucas_(), lmmp_param_assert, restrict, TALLOC_TYPE, TEMP_DECL , 以及 TEMP_FREE.

被这些函数引用 bench_is_strong_lucas(), lmmp_is_strong_lucas_(), lmmp_powmod_() , 以及 TEST_CASE().

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

◆ lmmp_mod_2p48sub1_()

mp_limb_t lmmp_mod_2p48sub1_ ( mp_srcptr p,
mp_size_t n )

计算 [p,n] % 2^48-1

参数
p被除数指针
n被除数的 limb 长度
警告
p!=NULL, n>0
返回
[numa,na] % 2^48-1

在文件 perfsqr.c 第 59 行定义.

59 {
60 lmmp_param_assert(n > 0 && p != NULL);
61
62 mp_limb_t c0 = 0, c1 = 0, c2 = 0;
63 mp_limb_t a0 = 0, a1 = 0, a2 = 0;
64
65 while (n >= 3) {
66 ADD(c0, a0, p[0]);
67 ADD(c1, a1, p[1]);
68 ADD(c2, a2, p[2]);
69 p += 3;
70 n -= 3;
71 }
72 if (n == 2) {
73 ADD(c0, a0, p[0]);
74 ADD(c1, a1, p[1]);
75 } else if (n == 1) {
76 ADD(c0, a0, p[0]);
77 }
78
79 mp_limb_t res = PARTS0(a0) + PARTS1(a1) + PARTS2(a2)
80 + PARTS1(c0) + PARTS2(c1) + PARTS0(c2);
81
82 res = (res & MASK48) + (res >> B3);
83 if (res >= MASK48)
84 res -= MASK48;
85 return res;
86}
#define c1
#define c0
#define ADD(c, a, val)
#define MASK48
Copyright (C) 2026 HJimmyK (Jericho Knox)
#define PARTS0(n)
#define PARTS1(n)
#define B3
#define PARTS2(n)

引用了 a0, a1, a2, ADD, B3, c0, c1, lmmp_mod_2p48sub1_(), lmmp_param_assert, MASK48, n, PARTS0, PARTS1 , 以及 PARTS2.

被这些函数引用 lmmp_invcbrt_newton_(), lmmp_mod_2p48sub1_() , 以及 lmmp_perfsqr_filter_().

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

◆ lmmp_modinv_()

mp_size_t lmmp_modinv_ ( mp_ptr dst,
mp_srcptr up,
mp_size_t un,
mp_srcptr mp,
mp_size_t mn )

模逆元(任意长度):求 [up,un]^{-1} mod [mp,mn]

参数
dst结果指针(长度至少为 mn 个limb)
up被求逆元数指针
un被求逆元数的 limb 长度
mp模数指针
mn模数的 limb 长度
警告
up!=NULL, un>0, mp!=NULL, mn>0, dst!=NULL, up[un-1]!=0, mp[mn-1]!=0, sep(dst,[up|mp])
返回
dst 的实际 limb 长度;0 表示逆元不存在(gcd(u,m)>1)
注解
结果落在 [0,m)。mn==1 时约化为标量路径。dst 允许与 up 别名(eqsep)

在文件 gcdext.c 第 724 行定义.

724 {
725 lmmp_param_assert(un > 0 && mn > 0);
726 lmmp_param_assert(up != NULL && mp != NULL && dst != NULL);
727 lmmp_param_assert(up[un - 1] != 0 && mp[mn - 1] != 0);
728
729 if (mn == 1) {
730 if (mp[0] == 1) {
731 dst[0] = 0;
732 return 1; // 模 1:逆元存在且为 0
733 }
734 ulong inv = lmmp_modinv_ulong_(lmmp_mod_1_(up, un, mp[0]), mp[0]);
735 if (inv == 0)
736 return 0;
737 dst[0] = inv;
738 return 1;
739 }
740
744 mp_ptr s = BALLOC_TYPE(mn + 1, mp_limb_t);
745 /* lmmp_div_ 要求 na>=nb:un<mn 时 u<m,余数即 u 自身 */
746 mp_size_t rn;
747 if (un < mn) {
748 lmmp_copy(r, up, un);
749 rn = un;
750 } else {
751 lmmp_div_(NULL, r, up, un, mp, mn);
752 rn = mn;
753 }
754 while (rn > 0 && r[rn - 1] == 0)
755 --rn;
756 if (rn == 0) {
758 return 0; // m | u 且 m > 1:无逆
759 }
760 mp_ssize_t sn;
761 mp_size_t gn = lmmp_gcdext_(g, s, &sn, NULL, NULL, r, rn, mp, mn);
762 if (gn != 1 || g[0] != 1) {
764 return 0;
765 }
766 /* s*r = 1 (mod m) → s*u = 1 (mod m)。s<0 时逆元 = m - |s|(|s| <= m/2
767 保证结果落在 (m/2, m),无借位);防御性上界复查后归一化 */
768 mp_size_t snn = sn < 0 ? -sn : sn;
769 lmmp_debug_assert(snn > 0 && snn <= mn);
770 if (sn < 0) {
771 lmmp_sub_(s, mp, mn, s, snn);
772 snn = mn;
773 }
774 if (snn == mn && lmmp_cmp_(s, mp, mn) >= 0) {
775 lmmp_sub_(s, s, mn, mp, mn);
776 }
777 while (snn > 0 && s[snn - 1] == 0)
778 --snn;
779 lmmp_debug_assert(snn > 0);
780 lmmp_copy(dst, s, snn);
782 return snn;
783}
ulong lmmp_modinv_ulong_(ulong u, ulong m)
模逆元(单 limb):求 u^{-1} mod m
mp_size_t lmmp_gcdext_(mp_ptr dstg, mp_ptr dsts, mp_ssize_t *sn, mp_ptr dstt, mp_ssize_t *tn, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
扩展欧几里得(通用分发入口):g = gcd(u,v),s*u + t*v = g

引用了 BALLOC_TYPE, lmmp_cmp_(), lmmp_copy, lmmp_debug_assert, lmmp_div_(), lmmp_gcdext_(), lmmp_mod_1_(), lmmp_modinv_(), lmmp_modinv_ulong_(), lmmp_param_assert, lmmp_sub_(), s, TEMP_B_DECL , 以及 TEMP_B_FREE.

被这些函数引用 lmmp_modinv_() , 以及 TEST_CASE().

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

◆ lmmp_modinv_ulong_()

ulong lmmp_modinv_ulong_ ( ulong u,
ulong m )

模逆元(单 limb):求 u^{-1} mod m

参数
u被求逆元数
m模数
警告
u!=0, m!=0
返回
逆元(落在 [0,m));m>1 且 gcd(u,m)>1(不存在)时返回 0;m==1 时返回 0(模 1 下逆元为 0)

在文件 gcdext.c 第 707 行定义.

707 {
708 lmmp_param_assert(u > 0 && m > 0);
709
710 if (m == 1)
711 return 0; // 模 1:逆元存在且为 0
712 ulong r = u % m;
713 if (r == 0)
714 return 0; // m | u 且 m > 1:无逆
715 slong s;
716 ulong g = lmmp_gcdext_11_(r, m, &s, NULL);
717 if (g != 1)
718 return 0;
719 // s*r = 1 (mod m),|s| <= m/2 → 归一化到 [0,m)
720 ulong sm = s < 0 ? (ulong)-s : (ulong)s;
721 return s < 0 ? m - sm : sm;
722}

引用了 lmmp_gcdext_11_(), lmmp_modinv_ulong_(), lmmp_param_assert , 以及 s.

被这些函数引用 lmmp_modinv_(), lmmp_modinv_ulong_() , 以及 TEST_CASE().

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

◆ lmmp_mulmod_ulong_()

ulong lmmp_mulmod_ulong_ ( ulong a,
ulong b,
ulong mod,
ulongp q )

计算两个无符号整数的乘积,对mod取模,商放入 q 中

参数
a第一个无符号整数
b第二个无符号整数
q商的结果指针
mod取模数
警告
a < mod, b < mod, q!=NULL
返回
余数

引用了 LMMP_API, lmmp_mulmod_ulong_(), lmmp_powmod_uint_odd_() , 以及 lmmp_powmod_ulong_odd_().

被这些函数引用 lmmp_mulmod_ulong_(), lmmp_mulmod_ulong_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_multinomial_()

mp_size_t lmmp_multinomial_ ( mp_ptr dst,
mp_size_t rn,
uint n,
const uintp r,
uint m )

计算多项式系数

参数
dst结果指针
rn结果指针的 limb 长度
nr[i] 的总和
r需要计算的系数的数组
m系数的个数
警告
m>1, n>0
注解
多项式系数为 ( r1+r2+...+rm )! / ( r1! * r2! * ... * rm!)
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API, lmmp_arith_seqprod_size_(), lmmp_multinomial_() , 以及 n.

被这些函数引用 lmmp_multinomial_(), lmmp_multinomial_() , 以及 TEST_CASE().

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

◆ lmmp_multinomial_size_()

mp_size_t lmmp_multinomial_size_ ( const uintp r,
uint m,
ulong * n )

计算多项式系数的 limb 缓冲区长度

参数
r需要计算的系数的数组
m系数的个数
n输出变量,将会被修改为 r[i] 的总和,即r1+r2+...+rm
返回
多项式系数的 limb 缓冲区长度(比实际长度多 1-2 个 limb)
注解
多项式系数为 ( r1+r2+...+rm )! / ( r1! * r2! * ... * rm!)
警告
我们使用 ulong* n 来同时计算 r[i] 的总和,因为 n 可能超过 0xffffffff。 我们预计算 n,这不仅可以作为后续多项式系数函数的参数传入。 同时也请调用者注意判断 n 是否超过了 0xffffffff 这是 lmmp_multinomial_ 函数的限制。

引用了 LMMP_API, lmmp_multinomial_size_() , 以及 n.

被这些函数引用 lmmp_multinomial_size_(), lmmp_multinomial_size_() , 以及 TEST_CASE().

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

◆ lmmp_nCr_()

mp_size_t lmmp_nCr_ ( mp_ptr dst,
mp_bitcnt_t bits,
mp_size_t rn,
uint n,
uint r )

计算 nCr 组合数 ( nCr = n!

/ (r!(n-r)!) )

参数
dst结果指针
bitsnCr 的2的因子数
rn结果指针的 limb 长度
n组合数的总数
r组合数的选择数
返回
返回 dst 的实际 limb 长度
警告
r<=n/2, n<=0xffffffff, dst!=NULL, rn>0

引用了 LMMP_API, lmmp_nCr_() , 以及 n.

被这些函数引用 lmmp_nCr_(), lmmp_nCr_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_nCr_size_()

mp_size_t lmmp_nCr_size_ ( uint n,
uint r,
mp_bitcnt_t * bits )

计算 nCr 组合数的 limb 缓冲区长度

参数
n组合数的总数
r组合数的选择数
bits被修改为 nCr 的2的因子数
警告
r<=n/2, bits!=NULL
返回
nCr 组合数的 limb 缓冲区长度(比实际长度多 1-2 个 limb)

引用了 LMMP_API, lmmp_nCr_size_() , 以及 n.

被这些函数引用 lmmp_nCr_size_(), lmmp_nCr_size_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_next_prime_ulong_()

ulong lmmp_next_prime_ulong_ ( ulong n)

大于n的下一个素数

参数
n起始点(不含)
警告
如果 n 大于等于ulong可表示最大的质数,则返回ulong_max
返回
大于n的下一个素数

在文件 is_prime_ulong.c 第 375 行定义.

375 {
378 return prime_short_table[idx];
379 } else if (n >= ULONG_PRIME_MAX) {
380 return MP_ULONG_MAX;
381 } else {
382 n += (n % 2 == 0) ? 1 : 2;
383 while (1) {
384 if (trial_div16(n)) {
385 n += 2;
386 } else {
388 return n;
389 } else {
390 n += 2;
391 }
392 }
393 }
394 }
395}
static int trial_div16(ulong n)
#define ULONG_PRIME_MAX
#define MP_ULONG_MAX
#define PRIME_SHORT_TABLE_SIZE
const ushort prime_short_table[6542]
Copyright (C) 2026 HJimmyK (Jericho Knox)
ushort lmmp_prime_cnt16_(ushort n)
计算小于等于 n 的素数数量

引用了 lmmp_is_prime_ulong_notrial_(), lmmp_next_prime_ulong_(), lmmp_prime_cnt16_(), MP_ULONG_MAX, n, prime_short_table, PRIME_SHORT_TABLE_SIZE, trial_div16() , 以及 ULONG_PRIME_MAX.

被这些函数引用 lmmp_next_prime_ulong_(), lmmp_powmod_(), pool_bits(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_nPr_()

mp_size_t lmmp_nPr_ ( mp_ptr dst,
mp_bitcnt_t bits,
mp_size_t rn,
ulong n,
ulong r )

计算 nPr 排列数 ( nPr = n!

/ (n-r)! )

参数
dst结果指针
bitsnPr 的2的因子数
rn结果指针的 limb 长度
n排列数的总数
r排列数的选择数
警告
n>=r, dst!=NULL, rn>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API, lmmp_nPr_() , 以及 n.

被这些函数引用 lmmp_nPr_(), lmmp_nPr_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_nPr_size_()

mp_size_t lmmp_nPr_size_ ( ulong n,
ulong r,
mp_bitcnt_t * bits )

计算 nPr 排列数的 limb 缓冲区长度

参数
n排列数的总数
r排列数的选择数
bits被修改为 nPr 的2的因子数
警告
r<=n, bits!=NULL
返回
nPr 排列数的 limb 缓冲区长度(比实际长度多)

引用了 LMMP_API, lmmp_nPr_size_() , 以及 n.

被这些函数引用 lmmp_nPr_size_(), lmmp_nPr_size_(), lmmp_odd_nCr_uint_(), pow_nPr_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_nthroot_()

void lmmp_nthroot_ ( mp_ptr dsts,
mp_ptr dstr,
mp_srcptr numa,
mp_size_t na,
ulong root,
mp_ptr tp )

计算算术根 [dsts,nr] = floor([numa,na]^(1/root))(任意 na/任意顶 limb)

参数
dsts结果指针(nr = ceil(na/root) 个 limb,顶 limb 恒非零)
dstr余数结果输出指针((root-1)*nr+1 个 limb,NULL 表示不计算余数)
numa被开方数指针(只读)
na被开方数的 limb 长度
root开方次数
tp临时区(至少 lmmp_nthroot_size_(na,root) 个 limb)
警告
na>0, numa[na-1]!=0, root>=4, root<=2^56, sep(dsts,dstr,numa,tp)
注解
任意长度输入的统一入口,恒为精确 floor 语义(dstr=NULL 不牺牲 精度,与 lmmp_cbrt_/lmmp_sqrt_ 的 [floor|round] 口径不同)。 对虚拟 Ã = A·2^root 求根后纯移位恢复 S(嵌套 floor 恒等式): log2/exp2 128bit 定点种子 + 位窗牛顿精化(层成本 M(e2/64) 与 root 解耦)+ 认证式窗口探针/全幂端点修正。root=4 走 sqrt∘sqrt 专用路线(嵌套 floor 恒等式,余数由两级 sqrtrem 代数展开)。ns<=1 域分派至 lmmp_nthroot_ulong_。

在文件 nthroot.c 第 294 行定义.

294 {
295 lmmp_param_assert(na > 0 && numa != NULL && numa[na - 1] != 0);
296 lmmp_param_assert(root >= 4 && root <= (1ull << 56));
297 lmmp_param_assert(dsts != NULL && tp != NULL);
298 mp_size_t nr = (na + (mp_size_t)root - 1) / (mp_size_t)root; // 根长
299
300 // 平凡域:A < 2^(64na) <= 2^root → 根为 1
301 // 除法形式等价于 (ulong)na * LIMB_BITS <= root 且避免大 na 乘法回绕
302 if (na <= root / LIMB_BITS) {
303 dsts[0] = 1;
304 if (dstr) {
305 lmmp_copy(dstr, numa, na);
306 lmmp_dec(dstr); // rem = A - 1(A >= 1,无下借)
307 lmmp_zero(dstr + na, (root - 1) * nr + 1 - na);
308 }
309 return;
310 }
311 if (na == 1) {
312 dsts[0] = lmmp_nthroot_ulong_(numa[0], root);
313 if (dstr) {
314 ulong acc = 1;
315 for (ulong i = 0; i < root; ++i) acc *= dsts[0];
316 dstr[0] = numa[0] - acc;
317 lmmp_zero(dstr + 1, (root - 1) * nr); // 契约区 [0, root) 余 [1, root)
318 }
319 return;
320 }
321
322 // 位长上限 2^64:na < 2^58 时无回绕(2^58 limb = 2^61 字节,现实不可分配)
323 ulong bl = LIMB_BITS * (ulong)(na - 1) + (ulong)lmmp_limb_bits_(numa[na - 1]);
324
325 /*
326 root=4 专用路线:sqrt∘sqrt 嵌套 floor 恒等式(与顶入口的
327 Ã = A·2^root 恢复同族定理)
328
329 floor(sqrt(floor(sqrt(A)))) = floor(A^(1/4))
330
331 双向夹逼:S = floor(A^(1/4)) ⟹ S² ≤ floor(sqrt(A)) ⟹ S⁴ ≤ A;
332 反向 (S+1)² > floor(sqrt(A)) ⟹ (S+1)² ≥ floor(sqrt(A))+1 ⟹
333 (S+1)⁴ > A。余数由两级 sqrtrem 展开:
334 A = q1² + r1 = (S²+r2)² + r1 ⟹ A - S⁴ = r2·(q1+S²) + r1
335 (q1 = floor(sqrt A),(S,r2) = sqrtrem(q1))。
336
337 长度全解析(免 trim 扫描):精确定理
338 bitlen(floor(sqrt(A))) = ceil(bl/2)、bitlen(S) = ceil(bl/4)
339 (2^(bl-1) ≤ A < 2^bl 两端开方夹逼,嵌套 ceil 复合),故两级
340 sqrt 的输入/输出长度均由 bl 推出;r1/r2 取 sqrt_ 写满的余数区
341 (含顶零)直接作 mul/add 操作数(加减乘不要求归一化),输出
342 先清零 dstr 再拷贝乘积容器全长(顶零拷入零区无害)。
343
344 tp 分段(值域 na ≤ 4·nr 保证覆盖):
345 q1/r1/r2 各 na/2+2,sum na/2+3,S nr+2,prd 3·nr+4。
346 */
347 if (root == 4) {
348 mp_ptr q1 = tp, r1 = q1 + na / 2 + 2, S = r1 + na / 2 + 2, r2v = S + nr + 2,
349 sum = r2v + na / 2 + 2, prd = sum + na / 2 + 3;
350 lmmp_sqrt_(q1, dstr ? r1 : NULL, numa, na, 0);
351 mp_size_t nq1 = (mp_size_t)(((bl + 1) / 2 + 63) >> 6); // bitlen(q1)=ceil(bl/2)
352 lmmp_sqrt_(S, dstr ? r2v : NULL, q1, nq1, 0);
353 mp_size_t sn = (mp_size_t)(((bl + 3) / 4 + 63) >> 6); // bitlen(S)=ceil(bl/4)(= nr)
354 if (dstr) {
355 // rem = r2·(q1 + S²) + r1
356 lmmp_sqr_(sum, S, sn);
357 mp_size_t s2n = 2 * sn;
358 mp_size_t un = nq1 > s2n ? nq1 : s2n; // q1+S² 容器长(add 长在前)
359 if (un > s2n) lmmp_zero(sum + s2n, un - s2n); // sqr 只写 [0,2sn),补零
360 mp_limb_t cy = lmmp_add_(sum, sum, un, q1, nq1);
361 if (cy) sum[un++] = cy;
362 mp_size_t r2n = nq1 / 2 + 1; // r2 余数区(sqrt_ 写满含零)
363 mp_size_t r1n = na / 2 + 1; // r1 余数区(sqrt_ 写满含零)
364 lmmp_mul_(prd, sum, un, r2v, r2n); // 长在前:un ≥ nq1 ≥ nq1/2+1
365 mp_size_t pn = un + r2n; // 乘积容器长(顶零 limb 无害)
366 lmmp_debug_assert(pn >= r1n); // un ≥ nq1 ≥ ceil(na/2)-1,+r2n ≥ r1n
367 mp_limb_t cy2 = lmmp_add_(prd, prd, pn, r1, r1n);
368 if (cy2) prd[pn++] = cy2; // 值界 rem < 2^(192·nr+3):pn ≥ 3nr 时进位恒 0
369 mp_size_t outr = (root - 1) * nr + 1;
370 if (pn > outr) pn = outr; // 值界保证 [pn, outr) 段恒零
371 lmmp_copy(dstr, prd, pn); // 拷贝容器长(含值上方的零 limb)
372 lmmp_zero(dstr + pn, outr - pn);
373 }
374 lmmp_copy(dsts, S, sn); // sn == nr(bl ∈ (64(na-1), 64na] 双侧夹逼)
375 return;
376 }
377
378 ulong B = bl + root; // bitlen(Ã)
379 ulong Lp = (B + root - 1) / root; // L' = bitlen(T)
380 slong shx; // x ≈ T·2^-shx(scale 记账)
381
382 // ---- scratch 布局(单块手动分段,生命周期接力;注释 [p,n):p 段首,n 段长)----
383 mp_size_t nqf = nr + 1;
384 const mp_size_t XW = nqf + 8; // 精化窗宽:xb/asmb/qb/a1/t2 五段共用
385 const mp_size_t DW = 2 * nqf + 18; // Db 段长(截断幂链结果/除数)
386 const mp_size_t BW = 2 * (nqf + 4) + 8; // 幂链乒乓单段长
387 const mp_size_t NW = 2 * nqf + 13; // Nseg 段长(被除数段/移位暂存)
388 mp_size_t Ycap = (mp_size_t)root * nr + 8;
389 {
390 mp_size_t yneed = na + (mp_size_t)(root >> 6) + 4;
391 if (Ycap < yneed) Ycap = yneed; // 全幂端点幂值界(见 size_ 注)
392 }
393 mp_ptr Y = tp; // [Y, Ycap] 终点幂/试探幂(回退)
394 mp_ptr Y2 = Y + Ycap; // [Y2, Ycap] 试探幂 (y+1)^root(回退)
395 mp_ptr work = Y2 + Ycap; // [work, na+4] 余数中转
396 mp_ptr xb = work + na + 4; // [xb, XW] 精化状态 x / 探针链结果 V
397 mp_ptr asmb = xb + XW; // [asmb, XW] 商/装配累加器 / 探针 Wc·L
398 mp_ptr qb = asmb + XW; // [qb, XW] q·root 移位段 / 探针 slack·Sh / 回退 y+1
399 mp_ptr a1 = qb + XW; // [a1, XW] (root-1)·x 暂存 / y 候选
400 mp_ptr t2 = a1 + XW; // [t2, XW] q·root·2^-X 段 / 探针 M 低位
401 mp_ptr Db = t2 + XW; // [Db, DW] 截断幂链结果/除数 D
402 mp_ptr bufa = Db + DW; // [bufa, BW] 幂链乒乓 a
403 mp_ptr bufb = bufa + BW; // [bufb, BW] 幂链乒乓 b
404 mp_ptr Nseg = bufb + BW; // [Nseg, NW] 被除数段/移位暂存(探针 M 高位接力)
405
406 // ---- 1) 种子:x0 ≈ T·2^(127-I),shx = I-127;xn/bx 显式(xb 高段无读者,不清零)----
408 ulong bx;
409 {
410 // y = log2(Ã) = (B-1) + log2(1+f),f 取 A 顶 129bit 去前导 1 的
411 // 128bit 小数(Ã 顶 bit 同 A)。y/root = I + (rem+f)/root,
412 // rem = (B-1) mod root(< 2^56 独占第 3 limb):
413 // 3 limb 定点 [f | rem] 除 root 得 128bit 商,exp2 后取 128bit
414 // 归一化尾数。
415 ulong flo, fhi;
416 if (bl >= 129) {
417 ulong s0 = bl - 129;
418 flo = lmmp_shr64_(numa, na, s0);
419 fhi = lmmp_shr64_(numa, na, s0 + 64);
420 } else {
421 mp_limb_t w[3] = {0, 0, 0};
422 mp_size_t m = na < 3 ? na : 3; // bl < 129 ⟹ na ≤ 3
423 lmmp_copy(w, numa, m);
424 unsigned sh = (unsigned)(129 - bl);
425 if (sh == 64) {
426 // bl=65(恰 2 limb、顶 limb=1):整 limb 上移,越过 shl_ 的
427 // [0,63] 契约域(asm 掩码行为未定义,须显式处理)
428 w[2] = w[1];
429 w[1] = w[0];
430 w[0] = 0;
431 } else {
432 mp_limb_t cy = lmmp_shl_(w, w, 3, sh);
433 (void)cy; // 高于 129bit 的进位即前导 1 之上,弃
434 }
435 flo = w[0];
436 fhi = w[1];
437 }
438 mp_limb_t fr[3];
439 log2_fixed_128(fr, fhi, flo); // fr = log2(1+f) 的 128bit 定点
440 fr[2] = (mp_limb_t)((B - 1) % root);
441 lmmp_div_1_(fr, fr, 3, root); // (rem·2^128 + f)/root,商 ≤ 2^128
442 mp_limb_t e[2];
443 exp2_fixed_128(e, fr[1], fr[0]); // 2^frac 的 128bit 小数
444 xb[0] = (e[0] >> 1) | (e[1] << 63);
445 xb[1] = (1ULL << 63) | (e[1] >> 1); // x0 = 2^127 + (e >> 1)
446 xn = 2;
447 bx = 128; // x0 ∈ [2^127, 2^128) 恰 128 bit
448 shx = (slong)((B - 1) / root) - 127;
449 }
450
451 // ---- 2) 位窗牛顿精化:e_eff = L'-shx → L'(全程显式长度,零 trim 扫描/零全段清零)----
452 slong lambda = (slong)lmmp_limb_bits_(root - 1) + 12;
453 for (;;) {
454 slong e_eff = (slong)Lp - shx;
455 if (e_eff >= (slong)Lp) break; // 种子直达域(shx ≤ 0);层出口恒 shx=0
456 slong e2 = 2 * e_eff - lambda; // e_eff ≥ 128 > λ ⟹ e2 > e_eff
457 int final_stage = 0;
458 if (e2 >= (slong)Lp) {
459 e2 = (slong)Lp;
460 final_stage = 1; // 终层后无条件退出(renorm ±1 不再依赖 e_eff 判定)
461 }
462 slong shx2 = (slong)Lp - e2;
463 slong delta = e2 - e_eff;
464
465 mp_size_t nq = (mp_size_t)((e2 + 63) / 64) + 1;
466 mp_size_t Lseg = 2 * nq + 3;
467 mp_size_t w = nq + 4;
468
469 // D = root·P,P = x^(root-1) 截断至 w limb(drop 为丢弃 bit 数)
470 slong drop;
471 mp_size_t pl = nthroot_pow_trunc_(Db, &drop, w, xb, xn, root - 1, bufa, bufb);
472 mp_limb_t cy = lmmp_mul_1_(Db, Db, pl, root);
473 mp_size_t dl = pl;
474 if (cy) Db[dl++] = cy;
475 // 除数取 D 的顶 nd limb [Db+dl-nd, nd)(nd ≤ nq+3;顶 limb 恒非零),
476 // 低位截断量 64·(dl-nd) 由尺度恒等式吸收。lmmp_div_ 内部归一化并
477 // 支持仅算商(dstr=NULL):div_s 的 MSB 契约、手工提窗移位与
478 // 商顶 limb 回收一并免去
479 mp_size_t nd = dl < nq + 3 ? dl : nq + 3;
480
481 // Nseg = A 的顶 Lseg limb(左补零语义)
482 nthroot_top_limbs_(Nseg, Lseg, numa, na, bl);
483
484 // q_seg = floor(Nseg/Dseg)(仅商;[asmb, Lseg-nd+1],顶 limb 可为 0,
485 // mul_1/移位不要求归一化,容器长直传)
486 lmmp_div_(asmb, NULL, Nseg, Lseg, Db + dl - nd, nd);
487 mp_size_t ql = Lseg - nd + 1;
488
489 /*
490 尺度恒等式(层核心):q_true := N_{e2}/y^(root-1) ≈ q_seg·root·2^-X,
491
492 X = 64·(dl-nd) + 64·Lseg - bl + root·shx2 - root + (root-1)·delta + drop
493
494 推导:Nseg = A·2^(64Lseg-bl)·(1±2^-64Lseg),
495 Dseg = floor(D/2^(64(dl-nd))) = root·P·2^-(64(dl-nd)),
496 P = x^(root-1)·2^-drop,y^(root-1) = x^(root-1)·2^((root-1)·delta),
497 N_{e2} = A·2^(root-root·shx2);代入相消即得(各 floor 误差
498 ≤ 1 ulp 由守卫吸收)。root>=5 时恒 dl >= nq+3(首层 bitlen(D)
499 >= 64(nq+3),之后 (root-1)e_eff 增速快于 e2),min 为防御。
500 */
501 slong X = 64 * (slong)(dl - nd) + 64 * (slong)Lseg - (slong)bl + (slong)root * shx2
502 - (slong)root + (slong)(root - 1) * delta + drop;
503
504 // t2 = (q_seg·root)·2^-X(值底对齐;X<0 时左移暂驻 Nseg,
505 // 与 a1 的相加直接消费驻留形态,不回拷)
506 mp_ptr tq;
507 mp_size_t tl;
508 {
509 mp_limb_t cy2 = lmmp_mul_1_(t2, asmb, ql, root);
510 tl = ql;
511 if (cy2) t2[tl++] = cy2;
512 if (X > 0) {
513 mp_size_t loff = (mp_size_t)(X >> 6);
514 if (loff >= tl) {
515 tl = 0; // 商整体低于窗(早层)→ t2 = 0
516 } else {
517 // shr_ 允许 dst<numa 重叠(含 shr=0 的整段拷贝分支)
518 lmmp_shr_(t2, t2 + loff, tl - loff, (mp_size_t)(X & 63));
519 tl -= loff;
520 }
521 tq = t2;
522 } else if (X < 0) {
523 mp_size_t loff = (mp_size_t)((-X) >> 6);
524 unsigned bit = (unsigned)((-X) & 63);
525 lmmp_zero(Nseg, loff);
526 mp_limb_t cy3 = lmmp_shl_(Nseg + loff, t2, tl, bit); // bit=0 时函数内即拷贝
527 tl += loff;
528 if (cy3) Nseg[tl++] = cy3;
529 lmmp_debug_assert(tl <= NW);
530 tq = Nseg;
531 } else {
532 tq = t2;
533 }
534 }
535
536 // a1 = (root-1)·x·2^delta 落位 asmb:[asmb, dloff) 清零 + 乘积左移
537 mp_size_t al;
538 {
539 mp_size_t dloff = (mp_size_t)(delta >> 6);
540 unsigned dbit = (unsigned)(delta & 63);
541 al = xn;
542 mp_limb_t cy4 = lmmp_mul_1_(asmb + dloff, xb, xn, root - 1);
543 if (cy4) asmb[dloff + al++] = cy4;
544 if (dbit) {
545 mp_limb_t cy5 = lmmp_shl_(asmb + dloff, asmb + dloff, al, dbit);
546 if (cy5) asmb[dloff + al++] = cy5;
547 }
548 lmmp_zero(asmb, dloff);
549 al += dloff;
550 }
551 lmmp_debug_assert(al <= XW);
552
553 // x' = floor((a1 + t2)/root):长者在前的单次 add + 原地单limb除
554 {
555 mp_ptr np;
556 mp_size_t nl;
557 mp_limb_t c = 0;
558 if (tl == 0) {
559 np = asmb;
560 nl = al;
561 } else if (al >= tl) {
562 c = lmmp_add_(asmb, asmb, al, tq, tl);
563 np = asmb;
564 nl = al;
565 } else {
566 c = lmmp_add_(tq, tq, tl, asmb, al);
567 np = tq;
568 nl = tl;
569 }
570 if (c) np[nl++] = c;
571 lmmp_div_1_(np, np, nl, root); // 原地(契约 eqsep),商高位补零
572
573 /*
574 x' 精确长度(免 trim 扫描):记 t = bx+delta(x·2^delta 的
575 位长,v := x·2^delta ≥ 2^(t-1))。num ≥ (root-1)·v ⟹
576 x' ≥ (root-1)/root·v - 1 ≥ (4/5)v - 1 ≥ 2^(t-2)(root≥5、
577 t ≥ 4)⟹ bitlen(x') ≥ t-1;层误差定理(e2 = 2·e_eff-λ
578 排程)给 x' ≤ v·(1+2^-59) < 2·v < 2^(t+1) ⟹ bitlen ≤ t+1。
579 两界跨 ≤2 bit ⟹ xn ∈ {limbs(t+1), limbs(t+1)-1},
580 单次顶 limb 探测即精确。
581 */
582 xn = (mp_size_t)((bx + (ulong)delta + 64) >> 6);
583 if (np[xn - 1] == 0) --xn;
584 bx = 64 * (ulong)(xn - 1) + (ulong)lmmp_limb_bits_(np[xn - 1]);
585 lmmp_copy(xb, np, xn);
586 }
587 // 不做 mantissa 归一化:shx ← shx2 保持排程精度语义(x' 的 bitlen
588 // 允许略低于 64·nq——牛顿准确度由 e2 = 2·e_eff-λ 的排程保证,
589 // 若按 limb 归一化上移会把"scale"虚标为"精度",下层排程基于虚标
590 // 精度直接 e2 → L' 会越过牛顿的二次收敛保证,终值误差 ~2^(L'-2e+λ))
591 shx = shx2;
592 if (final_stage) break;
593 }
594
595 // ---- 3) 终点:y0 = x·2^-shx ≈ T;S_cand = y0 >> 1,A 域先降后升 ----
596 // 层出口恒 shx=0(终层 e2=L' 钳制)→ 纯拷贝;种子直达域 shx<0
597 // (|shx| ≤ 126,x0 恰 128bit ⟹ 移后 bitlen = 128+shx 精确已知)
598 mp_ptr y = a1; // [y, XW)
599 mp_size_t yn;
600 if (shx < 0) {
601 mp_size_t loff = (mp_size_t)((-shx) >> 6);
602 unsigned bit = (unsigned)((-shx) & 63);
603 lmmp_shr_(y, xb + loff, xn - loff, bit); // bit=0 时函数内即拷贝
604 yn = xn - loff; // bitlen 恰 128+shx ≥ 2,顶 limb 非零
605 } else {
606 lmmp_debug_assert(shx == 0);
607 lmmp_copy(y, xb, xn);
608 yn = xn;
609 }
610 lmmp_shr_(y, y, yn, 1); // S_cand = y0 >> 1(库移位,原地)
611 if (y[yn - 1] == 0) --yn; // 仅 2^(64k) 精确形态掉 1 limb
612
613 /*
614 认证式窗口探针避免在终点计算全尺寸幂。
615
616 以截断幂链 V·2^dr ≈ P(P = y^root;drop 精确记账,相对误差
617 ε ≤ 2^(hb+66-64·w),V 恰 pl limb 且 MSB=1)与 A 的同尺度顶窗
618 Wc 做单侧认证比较。尺度对齐是精确的:C := A·2^-dr 为实值,
619 bitlen(C) = bl - dr 恰已知,shift = bitlen(C) - 64·pl ∈ {-1,0,1}
620 (由 C = V·(1±ε) 与 bitlen(V) = 64·pl 推出),Wc 取
621 nthroot_top_limbs_ 的 64·pl bit 顶窗后按 shift 移位,恒有
622 Wc ≤ C < Wc + 2。结合 P 的双侧界 P ∈ [(V-δ0)·2^dr,
623 (V+δ0)·2^dr](δ0 = 2^(hb+68) ≥ 4·ε·2^64·pl)与 A 的界
624 A ∈ [Wc·2^dr, (Wc+2)·2^dr),四项判决均为无条件定理:
625
626 dec-cert V - Wc >= 2^(hb+69) ⟹ P > A
627 le-cert Wc - V >= 2^(hb+69) ⟹ P <= A
628 done-cert (V-δ0)·root >= (Wc-V+δ0+2)·(ȳ+1)·2^s ⟹ (y+1)^root > A
629 inc-cert (V+δ0)·root·(1+2^-c1) <= (Wc-V-δ0)·ȳ·2^s ⟹ (y+1)^root <= A
630
631 done/inc 由二项式首项 (y+1)^root >= P + root·y^(root-1)(整数、
632 精确)与 (1+1/y)^root <= 1+u(1+u)(u = root/y <= 2^-c1,
633 c1 = bitlen(y)-58)承载不等式方向;ȳ = floor(y/2^s),
634 s = bitlen(y)-128(gate bitlen(y) >= 256 保证 2 limb ȳ 与富余)。
635 le-cert + done-cert ⟹ y = S(定理),无需任何幂。
636
637 落入不确定带(|V-Wc| < 2^(hb+69),或两证书均失败;随机输入
638 概率 ~2^-(hb+69),完全幂/区间顶构造必中)或预算耗尽时回退
639 全幂端点(先降后升单调循环,从任意起点收敛)。概率只决定
640 快路径命中率,正确性由定理 + 精确回退承载。rem 口径在 y
641 认证后仍需一次全幂(余数需要精确 y^root),root-only 免。
642
643 y 的 ±1 调整经 nthroot_inc_len_/nthroot_dec_len_ 维护精确长度
644 (yn 全程有效,探针/回退的后续读者不再扫描)。
645 */
646 int settled = 0;
647 for (int iter = 0; iter < 4 && !settled; ++iter) {
648 if (yn < 4 || 64 * (yn - 1) + lmmp_limb_bits_(y[yn - 1]) < 256) break;
649 unsigned hb = lmmp_limb_bits_(root) - 1; // root <= 2^56 ⟹ hb <= 55
650 mp_limb_t d0hi = 1ULL << (hb + 4); // δ0 = 2^(hb+68) 的 limb 对 {0, d0hi}
651 slong dr;
652 mp_ptr V = xb; // 链结果(pl limb,MSB=1)
653 mp_size_t pl = nthroot_pow_trunc_(V, &dr, nr + 5, y, yn, root, bufa, bufb);
654 lmmp_debug_assert(pl >= 8);
655 slong shift = (slong)bl - dr - 64 * (slong)pl;
656 if (shift < -1 || shift > 1) break; // 定理域外(不可能):回退
657 mp_ptr Wc = asmb; // W0 → 按 shift 移位后的比较窗
658 nthroot_top_limbs_(Wc, pl, numa, na, bl);
659 mp_size_t wl = pl;
660 if (shift > 0) {
661 // C = ÷2^shift(à ∈ [W0, W0+1))⟹ shift=+1: C ∈ [2W0, 2W0+2)
662 mp_limb_t wc = lmmp_shl_(Wc, Wc, pl, 1); // W0 MSB=1 ⟹ 恒产生第 pl limb
663 lmmp_debug_assert(wc == 1);
664 Wc[pl] = wc;
665 wl = pl + 1;
666 } else if (shift < 0) {
667 // shift=-1: C = Ã/2 ∈ [W0/2, W0/2 + 1/2) ⟹ C ∈ [W0>>1, (W0>>1)+1)
668 lmmp_shr_(Wc, Wc, pl, 1); // 顶 limb ≥ 2^62,wl 不变
669 }
670 // slack = |V - Wc|(SPL limb 容器,高位清零),方向 vgtw
671 mp_size_t SPL = pl + 1;
672 mp_ptr slk = qb;
673 lmmp_zero(slk + wl, SPL - wl);
674 int vgtw = nthroot_cmp_ext_(V, pl, Wc, wl) >= 0;
675 if (vgtw) lmmp_sub_(slk, V, pl, Wc, wl);
676 else lmmp_sub_(slk, Wc, wl, V, pl);
677 mp_size_t sn = SPL;
678 while (sn > 0 && slk[sn - 1] == 0) --sn; // 数据依赖(slack 值任意小)
679 // 守卫带宽判定:slack >= 2^(hb+69) ⟺ bitlen(slack) >= hb+70
680 if (sn < 2 || lmmp_limb_bits_(slk[sn - 1]) + 64 * (unsigned)(sn - 1) < hb + 70)
681 break; // 不确定带 → 回退全幂端点
682 if (vgtw) {
683 yn = nthroot_dec_len_(y, yn); // dec-cert:P > A(y 过高,牛顿 +1 残余)
684 continue;
685 }
686 // le-cert 成立:P <= A。done-cert / inc-cert 判定
687 unsigned tb = lmmp_limb_bits_(y[yn - 1]);
688 mp_size_t s = 64 * (yn - 1) + (mp_size_t)tb - 128;
689 mp_limb_t alo = lmmp_shr64_(y, yn, (ulong)s);
690 mp_limb_t ahi = lmmp_shr64_(y, yn, (ulong)s + 64);
691 mp_size_t loff = s >> 6;
692 unsigned sbit = (unsigned)(s & 63);
693 // L = (V-δ0)·root;M = (slack+δ0+2)·(ȳ+1)·2^s(落位 t2+loff 再原地位移)
694 mp_ptr L = asmb; // Wc 已消费(slack 物化于 slk)
695 lmmp_copy(L, V, pl);
696 nthroot_sub_small_(L, pl, 0, d0hi);
697 mp_limb_t lcy = lmmp_mul_1_(L, L, pl, (mp_limb_t)root);
698 mp_size_t ln = pl;
699 if (lcy) {
700 L[ln] = lcy;
701 ++ln;
702 }
703 nthroot_add_small_(slk, SPL, 2, d0hi);
704 mp_limb_t bp1[3] = {alo + 1, ahi + (alo + 1 == 0), 0};
705 bp1[2] = (bp1[0] == 0 && bp1[1] == 0); // ȳ+1 进位到 2^128 的形态
706 mp_size_t bpn = 2 + (bp1[2] != 0);
707 lmmp_zero(t2, loff); // M = 乘积 << (64·loff):低位 loff limb 必须显式清零
708 lmmp_mul_(t2 + loff, slk, SPL, bp1, bpn);
709 mp_size_t mn = loff + SPL + bpn;
710 if (sbit) {
711 mp_limb_t mcy = lmmp_shl_(t2 + loff, t2 + loff, SPL + bpn, sbit);
712 if (mcy) {
713 t2[loff + SPL + bpn] = mcy;
714 ++mn;
715 }
716 }
717 if (nthroot_cmp_ext_(L, ln, t2, mn) >= 0) {
718 settled = 1; // done-cert:(y+1)^root > A,结合 le-cert 得 y = S
719 break;
720 }
721 // L2 = (V+δ0)·root;M2 = (slack-δ0)·ȳ·2^s;判 L2·(1+2^-c1) <= M2
722 lmmp_copy(L, V, pl);
723 nthroot_add_small_(L, pl, 0, d0hi);
724 lcy = lmmp_mul_1_(L, L, pl, (mp_limb_t)root);
725 ln = pl;
726 if (lcy) {
727 L[ln] = lcy;
728 ++ln;
729 }
730 nthroot_sub_small_(slk, SPL, 2, 2 * d0hi); // (slack+δ0+2)-(2+2δ0) = slack-δ0 >= 0(le-cert 守卫 slack >= 2δ0)
731 mp_limb_t ybar[2] = {alo, ahi};
732 lmmp_zero(t2, loff); // 同上:低位清零
733 lmmp_mul_(t2 + loff, slk, SPL, ybar, 2);
734 mn = loff + SPL + 2;
735 if (sbit) {
736 mp_limb_t mcy = lmmp_shl_(t2 + loff, t2 + loff, SPL + 2, sbit);
737 if (mcy) {
738 t2[loff + SPL + 2] = mcy;
739 ++mn;
740 }
741 }
742 // L2 += L2 >> c1 再 +1(整数化 L2·(1+2^-c1) 的上界)
743 mp_size_t c1 = s + 70;
744 mp_size_t l2 = c1 >> 6;
745 unsigned b2 = (unsigned)(c1 & 63);
746 mp_size_t shn = ln - l2;
747 mp_ptr Sh = qb; // slack 已消费(M2 已物化于 t2)
748 lmmp_shr_(Sh, L + l2, shn, b2); // b2=0 时函数内即拷贝
749 mp_limb_t acy = lmmp_add_(L, L, ln, Sh, shn);
750 if (acy) {
751 L[ln] = acy;
752 ++ln;
753 }
754 acy = lmmp_add_1_(L, L, ln, 1);
755 if (acy) {
756 L[ln] = acy;
757 ++ln;
758 }
759 if (nthroot_cmp_ext_(L, ln, t2, mn) <= 0) {
760 yn = nthroot_inc_len_(y, yn); // inc-cert:(y+1)^root <= A,y+1 成为新候选
761 continue;
762 }
763 break; // 不确定带 → 回退全幂端点
764 }
765
766 mp_size_t tn = 0; // Y = y^root 的精确长度(回退/认证幂共用)
767 if (!settled) {
768 // 全幂回退端点(不确定带 / 小根 / bitlen(y) < 256 / 预算耗尽):
769 // 先降后升单调修正(降循环至 y^root <= A,升循环至 (y+1)^root > A),
770 // 从任意起点收敛于真值;Y 恒持有 y^root 供余数。注意与上方探针的
771 // 区别:早轮被否决的 wcmp 以未认证的截断比较直接作循环条件(无尺度
772 // 恒等式、无双侧界、误判即失控);现行探针的每次判决都是单侧定理 +
773 // 精确回退。y 长度经 inc/dec 助手维护,幂比较用 cmp_ext 直接吃
774 // 精确长度(无零填充)。
775 int dec_cnt = 0, inc_cnt = 0;
776 for (;;) {
777 tn = lmmp_pow_(Y, Ycap, y, yn, root);
778 if (nthroot_cmp_ext_(Y, tn, numa, na) <= 0) break;
779 yn = nthroot_dec_len_(y, yn);
780 ++dec_cnt;
781 }
782 for (;;) {
783 lmmp_copy(qb, y, yn);
784 mp_size_t qn = nthroot_inc_len_(qb, yn);
785 mp_size_t tn2 = lmmp_pow_(Y2, Ycap, qb, qn, root);
786 if (nthroot_cmp_ext_(Y2, tn2, numa, na) > 0) break;
787 lmmp_copy(y, qb, qn);
788 yn = qn;
789 mp_ptr sw = Y;
790 Y = Y2;
791 Y2 = sw; // Y 恒持有 y^root(供余数)
792 tn = tn2;
793 ++inc_cnt;
794 }
795 lmmp_debug_assert(dec_cnt <= 8 && inc_cnt <= 8); // 误差预算绊线(定理 ≤ ~4)
796 } else if (dstr) {
797 // y = S 已由定理认证;余数需要精确 y^root,付一次全幂(root-only 免)
798 tn = lmmp_pow_(Y, Ycap, y, yn, root);
799 int yle = nthroot_cmp_ext_(Y, tn, numa, na); // le-cert 绊线(cmp 先算局部变量)
800 lmmp_debug_assert(yle <= 0);
801 }
802
803 // 输出根:yn ≤ nr 恒成立(y = S 精确,S < 2^(64nr)),min 为防御
804 lmmp_copy(dsts, y, yn < nr ? yn : nr);
805 if (yn < nr) lmmp_zero(dsts + yn, nr - yn);
806 if (dstr) {
807 // rem = A - y^root:值 < A < 2^(64na) ⟹ 差在 [work, na) 内;
808 // 契约区 [(root-1)nr+1] 的顶零直接写 dstr(勿经 work 补零——
809 // nr=1 大 root 形状 outr ≫ na+13nq 会越出 tp 末端)
810 mp_size_t yl = tn > na ? na : tn;
811 mp_limb_t bo = lmmp_sub_(work, numa, na, Y, yl);
812 lmmp_debug_assert(bo == 0);
813 mp_size_t outr = (root - 1) * nr + 1;
814 mp_size_t on = outr < na ? outr : na;
815 lmmp_copy(dstr, work, on);
816 lmmp_zero(dstr + on, outr - on);
817 }
818}
static mp_limb_t lmmp_shr64_(mp_srcptr p, mp_size_t n, uint64_t s)
#define B
#define lmmp_dec(p)
减1宏(预期无借位)
void exp2_fixed_128(uint64_t *dst, uint64_t high, uint64_t low)
计算 floor(exp2(x/B)*B-B), B=2^128
void log2_fixed_128(uint64_t *dst, uint64_t high, uint64_t low)
计算 floor(log2(1+x/B)*B), B=2^128
#define bp1
#define b2
static mp_size_t nthroot_inc_len_(mp_ptr y, mp_size_t yn)
[y,yn] += 1 并维护精确长度
static void nthroot_top_limbs_(mp_ptr dst, mp_size_t nlimbs, mp_srcptr numa, mp_size_t na, ulong bl)
提取 [numa,na] 的顶 nlimbs 个 limb(左补零语义)
static void nthroot_add_small_(mp_ptr p, mp_size_t n, mp_limb_t c0, mp_limb_t c1)
[p,n] += c0 + c1·B(探针证书的小常数增量)
static mp_size_t nthroot_pow_trunc_(mp_ptr dst, slong *drop, mp_size_t wlimbs, mp_srcptr base, mp_size_t bn, ulong exp, mp_ptr bufa, mp_ptr bufb)
计算窗口截断幂链 [dst] ≈ [base,bn]^exp / 2^(*drop)
static void nthroot_sub_small_(mp_ptr p, mp_size_t n, mp_limb_t c0, mp_limb_t c1)
[p,n] -= c0 + c1·B(探针证书的小常数量减)
static int nthroot_cmp_ext_(mp_srcptr a, mp_size_t an, mp_srcptr b, mp_size_t bn)
零扩展比较:把 [a,an] 与 [b,bn] 视作等长后比较
static mp_size_t nthroot_dec_len_(mp_ptr y, mp_size_t yn)
[y,yn] -= 1 并维护精确长度
mp_size_t lmmp_pow_(mp_ptr dst, mp_size_t rn, mp_srcptr base, mp_size_t n, ulong exp)
计算大整数幂 [dst,rn] = [base,n] ^ exp
ulong lmmp_nthroot_ulong_(ulong n, ulong root)
计算 floor(n^(1/root))
void lmmp_sqrt_(mp_ptr dsts, mp_ptr dstr, mp_srcptr numa, mp_size_t na, mp_size_t nf)
计算 [numa,na] * B^(2*nf) 的平方根和余数
定义 sqrt.c:441

引用了 a1, B, b2, bp1, c1, exp2_fixed_128(), LIMB_BITS, lmmp_add_(), lmmp_add_1_(), lmmp_copy, lmmp_debug_assert, lmmp_dec, lmmp_div_(), lmmp_div_1_(), lmmp_limb_bits_, lmmp_mul_(), lmmp_mul_1_(), lmmp_nthroot_(), lmmp_nthroot_ulong_(), lmmp_param_assert, lmmp_pow_(), lmmp_shl_(), lmmp_shr64_(), lmmp_shr_(), lmmp_sqr_, lmmp_sqrt_(), lmmp_sub_(), lmmp_zero, log2_fixed_128(), nthroot_add_small_(), nthroot_cmp_ext_(), nthroot_dec_len_(), nthroot_inc_len_(), nthroot_pow_trunc_(), nthroot_sub_small_(), nthroot_top_limbs_(), r1, s, tp , 以及 xn.

被这些函数引用 lmmp_invcbrt_newton_(), lmmp_nthroot_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_nthroot_size_()

mp_size_t lmmp_nthroot_size_ ( mp_size_t na,
ulong root )

计算 lmmp_nthroot_ 所需的 tp 缓冲区长度(任意长度输入入口)

参数
na被开方数的 limb 长度
root开方次数
返回
tp 至少需要的 limb 数
警告
na>0, root>=4, root<=2^56

在文件 nthroot.c 第 283 行定义.

283 {
284 lmmp_param_assert(na > 0);
285 lmmp_param_assert(root >= 4 && root <= (1ull << 56));
286 mp_size_t nr = (na + (mp_size_t)root - 1) / (mp_size_t)root;
287 mp_size_t nq = nr + 1; // ceil(L'/64) ≤ ceil((64na+root)/(64root)) + 0 ≤ nr+1
288 mp_size_t ycap = (mp_size_t)root * nr + 8;
289 mp_size_t yneed = na + (mp_size_t)(root >> 6) + 4;
290 if (ycap < yneed) ycap = yneed;
291 return 2 * ycap + na + 4 + 13 * nq + 123;
292}

引用了 lmmp_nthroot_size_() , 以及 lmmp_param_assert.

被这些函数引用 lmmp_invcbrt_newton_(), lmmp_nthroot_size_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_nthroot_ulong_()

ulong lmmp_nthroot_ulong_ ( ulong n,
ulong root )

计算 floor(n^(1/root))

参数
n被开方数
root开方次数
返回
floor(n^(1/root))
注解
root=0时,返回0

在文件 nthroot_ulong.c 第 51 行定义.

51 {
52 ulong x, currval, base, upper_limit;
53
54 if (n == 0 || root == 0)
55 return 0;
56 if (root == 1)
57 return n;
58 if (root == 2)
59 return lmmp_sqrt_ulong_(n);
60 if (root == 3)
61 return lmmp_cbrt_ulong_(n);
62
63 if (root >= LIMB_BITS || n < (1ULL << root))
64 return 1;
65
66 /* n <= upper_limit^root */
67 upper_limit = max_base[root - 4];
68
69 if (upper_limit == 2)
70 return upper_limit;
71
72 /* upper_limit = 2 for root >= 41 */
73 lmmp_debug_assert(root <= 40);
74
75 if (root == 4)
76 x = sqrt(sqrt(n));
77 else
78 x = expf(inv_table[root - 5] * logf(n));
79
80 base = x;
81
82 if (base >= upper_limit)
83 base = upper_limit - 1;
84
85 currval = pow_n(base, root);
86 if (currval == n)
87 return base;
88
89 while (currval <= n) {
90 base++;
91 currval = pow_n(base, root);
92 if (base == upper_limit)
93 break;
94 }
95
96 while (currval > n) {
97 base--;
98 currval = pow_n(base, root);
99 }
100
101 return base;
102}
static const float inv_table[]
static ulong pow_n(ulong x, ulong n)
Copyright (C) 2026 HJimmyK (Jericho Knox)
static const uint16_t max_base[]
ulong lmmp_sqrt_ulong_(ulong a)
计算算术平方根 floor(sqrt(a))

引用了 inv_table, LIMB_BITS, lmmp_cbrt_ulong_(), lmmp_debug_assert, lmmp_nthroot_ulong_(), lmmp_sqrt_ulong_(), max_base, n , 以及 pow_n().

被这些函数引用 lmmp_invcbrt_newton_(), lmmp_nthroot_(), lmmp_nthroot_ulong_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_odd_factorial_uint_()

mp_size_t lmmp_odd_factorial_uint_ ( mp_ptr dst,
mp_size_t rn,
uint n )

计算 n!

阶乘的奇数部分

参数
dst结果指针
rn结果指针的 limb 长度(factorial_size_ 函数的返回值 - bits/LIMB_BITS)
n阶乘的阶数
警告
n>0xffff, dst!=NULL, rn>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API, lmmp_odd_factorial_uint_() , 以及 n.

被这些函数引用 lmmp_2factorial_(), lmmp_factorial_(), lmmp_odd_factorial_(), lmmp_odd_factorial_uint_() , 以及 lmmp_odd_factorial_uint_().

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

◆ lmmp_odd_nCr_uint_()

mp_size_t lmmp_odd_nCr_uint_ ( mp_ptr dst,
mp_size_t rn,
uint n,
uint r )

计算 nCr 组合数的奇数部分

参数
dst结果指针
rn结果指针的 limb 长度
n组合数的总数
r组合数的选择数
返回
返回 dst 的实际 limb 长度
警告
r<=n/2, 0xffff<n, dst!=NULL, rn>0

引用了 LMMP_API, lmmp_odd_nCr_uint_() , 以及 n.

被这些函数引用 lmmp_nCr_(), lmmp_odd_nCr_uint_() , 以及 lmmp_odd_nCr_uint_().

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

◆ lmmp_odd_nCr_ushort_()

mp_size_t lmmp_odd_nCr_ushort_ ( mp_ptr dst,
mp_size_t rn,
uint n,
uint r )

计算 nCr 组合数的奇数部分

参数
dst结果指针
rn结果指针的 limb 长度
n组合数的总数
r组合数的选择数
返回
返回 dst 的实际 limb 长度
警告
r<=n/2, n<=0xffff, dst!=NULL, rn>0

引用了 LMMP_API, lmmp_odd_nCr_ushort_() , 以及 n.

被这些函数引用 lmmp_nCr_(), lmmp_odd_nCr_ushort_() , 以及 lmmp_odd_nCr_ushort_().

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

◆ lmmp_odd_nPr_uint_()

mp_size_t lmmp_odd_nPr_uint_ ( mp_ptr dst,
mp_size_t rn,
ulong n,
ulong r )

计算 nPr 排列数的奇数部分

参数
dst结果指针
rn结果指针的 limb 长度(nPr_size_ 函数的返回值 - bits/LIMB_BITS)
n排列数的总数
r排列数的选择数
警告
0xffffffff>=n>=r, dst!=NULL, rn>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API, lmmp_odd_nPr_uint_() , 以及 n.

被这些函数引用 _odd_nPr_(), lmmp_nPr_(), lmmp_odd_nPr_uint_() , 以及 lmmp_odd_nPr_uint_().

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

◆ lmmp_odd_nPr_ulong_()

mp_size_t lmmp_odd_nPr_ulong_ ( mp_ptr dst,
mp_size_t rn,
ulong n,
ulong r )

计算 nPr 排列数的奇数部分

参数
dst结果指针
rn结果指针的 limb 长度(nPr_size_ 函数的返回值 - bits/LIMB_BITS)
n排列数的总数
r排列数的选择数
警告
n>=r, dst!=NULL, rn>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API, lmmp_odd_nPr_ulong_() , 以及 n.

被这些函数引用 lmmp_nPr_(), lmmp_odd_nPr_ulong_() , 以及 lmmp_odd_nPr_ulong_().

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

◆ lmmp_odd_nPr_ushort_()

mp_size_t lmmp_odd_nPr_ushort_ ( mp_ptr dst,
mp_size_t rn,
ulong n,
ulong r )

计算 nPr 排列数的奇数部分

参数
dst结果指针
rn结果指针的 limb 长度(nPr_size_ 函数的返回值 - bits/LIMB_BITS)
n排列数的总数
r排列数的选择数
警告
0xffff>=n>=r, dst!=NULL, rn>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API, lmmp_odd_nPr_ushort_() , 以及 n.

被这些函数引用 _odd_nPr_(), lmmp_2factorial_(), lmmp_factorial_(), lmmp_nPr_(), lmmp_odd_factorial_(), lmmp_odd_multinomial_ushort_(), lmmp_odd_nCr_ushort_(), lmmp_odd_nPr_ushort_() , 以及 lmmp_odd_nPr_ushort_().

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

◆ lmmp_perfsqr_()

bool lmmp_perfsqr_ ( mp_srcptr p,
mp_size_t n )

判断[p,n]是否为完全平方数

参数
p输入指针
n输入的 limb 长度
警告
p!=NULL, n>0, p[n-1]>0
返回
为完全平方数返回 true,否则返回 false

在文件 perfsqr.c 第 204 行定义.

204 {
205 lmmp_param_assert(n > 0 && p != NULL);
206 lmmp_param_assert(p[n - 1] > 0);
207 bool filter, ret;
208
209 filter = lmmp_perfsqr_filter_(p, n);
210 if (filter == false) return false;
211
212 TEMP_DECL;
214 mp_ptr restrict dstr = tp + n / 2 + 1;
215 lmmp_sqrt_(tp, dstr, p, n, 0);
216 ret = lmmp_zero_q_(dstr, n / 2 + 1);
217 TEMP_FREE;
218 return ret;
219}
bool lmmp_perfsqr_filter_(mp_srcptr p, mp_size_t n)
非完全平方数过滤器

引用了 lmmp_param_assert, lmmp_perfsqr_(), lmmp_perfsqr_filter_(), lmmp_sqrt_(), lmmp_zero_q_(), n, restrict, TALLOC_TYPE, TEMP_DECL, TEMP_FREE , 以及 tp.

被这些函数引用 ipn_lucas_i_(), lmmp_invcbrt_newton_(), lmmp_perfsqr_() , 以及 TEST_CASE().

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

◆ lmmp_perfsqr_filter_()

bool lmmp_perfsqr_filter_ ( mp_srcptr p,
mp_size_t n )

非完全平方数过滤器

参数
p输入指针
n输入的 limb 长度
警告
p!=NULL, n>0, p[n-1]>0
返回
false 意味着必定为非完全平方数,所有完全平方数和部分非完全平方数会返回 true
注解
此过滤器主要针对随机输入情况,对于大概率是完全平方数的输入,可以无需此函数。

在文件 perfsqr.c 第 191 行定义.

191 {
192 lmmp_param_assert(n > 0 && p != NULL);
193 lmmp_param_assert(p[n - 1] > 0);
194 if (n == 1) return lmmp_perfsqr_filter_1_(p[0]);
195 mp_limb_t a = p[0] % 256;
196 if (!is_perfsqr_p256(a))
197 return false;
199 return is_perfsqr_p9(r % 9) && is_perfsqr_p5(r % 5) && is_perfsqr_p7(r % 7) && is_perfsqr_p13(r % 13) &&
200 is_perfsqr_p17(r % 17) && is_perfsqr_p97(r % 97) && is_perfsqr_p241(r % 241) &&
201 is_perfsqr_p257(r % 257) && is_perfsqr_p673(r % 673);
202}
bool lmmp_perfsqr_filter_1_(mp_limb_t p)
非完全平方数过滤器
mp_limb_t lmmp_mod_2p48sub1_(mp_srcptr p, mp_size_t n)
计算 [p,n] % 2^48-1
static bool is_perfsqr_p7(uchar r)
static bool is_perfsqr_p241(ushort r)
static bool is_perfsqr_p17(uchar r)
static bool is_perfsqr_p256(uchar r)
static bool is_perfsqr_p673(ushort r)
static bool is_perfsqr_p13(uchar r)
static bool is_perfsqr_p257(ushort r)
static bool is_perfsqr_p9(uchar r)
static bool is_perfsqr_p5(uchar r)
static bool is_perfsqr_p97(uchar r)

引用了 is_perfsqr_p13(), is_perfsqr_p17(), is_perfsqr_p241(), is_perfsqr_p256(), is_perfsqr_p257(), is_perfsqr_p5(), is_perfsqr_p673(), is_perfsqr_p7(), is_perfsqr_p9(), is_perfsqr_p97(), lmmp_mod_2p48sub1_(), lmmp_param_assert, lmmp_perfsqr_filter_(), lmmp_perfsqr_filter_1_() , 以及 n.

被这些函数引用 lmmp_invcbrt_newton_(), lmmp_perfsqr_(), lmmp_perfsqr_filter_() , 以及 TEST_CASE().

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

◆ lmmp_perfsqr_filter_1_()

bool lmmp_perfsqr_filter_1_ ( mp_limb_t p)

非完全平方数过滤器

参数
p输入数
警告
p>0
返回
false 意味着必定为非完全平方数,所有完全平方数和部分非完全平方数会返回 true
注解
此过滤器主要针对随机输入情况,对于大概率是完全平方数的输入,可以无需此函数。

在文件 perfsqr.c 第 181 行定义.

181 {
182 lmmp_param_assert(p > 0);
183 mp_limb_t a = p % 256;
184 if (!is_perfsqr_p256(a)) return false;
185 p = p % MASK48;
186 return is_perfsqr_p9(p % 9) && is_perfsqr_p5(p % 5) && is_perfsqr_p7(p % 7) && is_perfsqr_p13(p % 13) &&
187 is_perfsqr_p17(p % 17) && is_perfsqr_p97(p % 97) && is_perfsqr_p241(p % 241) &&
188 is_perfsqr_p257(p % 257) && is_perfsqr_p673(p % 673);
189}

引用了 is_perfsqr_p13(), is_perfsqr_p17(), is_perfsqr_p241(), is_perfsqr_p256(), is_perfsqr_p257(), is_perfsqr_p5(), is_perfsqr_p673(), is_perfsqr_p7(), is_perfsqr_p9(), is_perfsqr_p97(), lmmp_param_assert, lmmp_perfsqr_filter_1_() , 以及 MASK48.

被这些函数引用 lmmp_invcbrt_newton_(), lmmp_perfsqr_filter_(), lmmp_perfsqr_filter_1_() , 以及 TEST_CASE().

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

◆ lmmp_pow_()

mp_size_t lmmp_pow_ ( mp_ptr dst,
mp_size_t rn,
mp_srcptr base,
mp_size_t n,
ulong exp )

计算大整数幂 [dst,rn] = [base,n] ^ exp

参数
dst结果指针
rn结果指针的 limb 长度
base底数指针
n底数指针的 limb 长度
exp指数
警告
n>0, base[n-1]!=0, sep(dst,base), exp>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API, lmmp_fibonacci2_(), lmmp_fibonacci_(), lmmp_fibonacci_size_(), lmmp_pow_() , 以及 n.

被这些函数引用 check_floor(), lmmp_nthroot_(), lmmp_pow_(), lmmp_pow_(), TEST_CASE(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_pow_1_()

mp_size_t lmmp_pow_1_ ( mp_ptr dst,
mp_size_t rn,
mp_limb_t base,
ulong exp )

计算幂次方 [dst,rn] = [base,1] ^ exp

参数
dst结果指针
base底数
exp指数
警告
base>=1, exp>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API , 以及 lmmp_pow_1_().

被这些函数引用 check_pow1_agree(), check_pow1_laws(), lmmp_pow_(), lmmp_pow_1_(), lmmp_pow_1_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_pow_1_size_()

mp_size_t lmmp_pow_1_size_ ( mp_limb_t base,
ulong exp )

计算幂次方需要的limb缓冲区长度 base ^ exp

参数
base底数
exp指数
警告
exp>0, base>=1
返回
返回值为 base^exp 需要的 limb 缓冲区长度(比实际长度多)

在文件 pow.c 第 65 行定义.

65 {
66 lmmp_param_assert(base >= 1);
67 lmmp_param_assert(exp > 0);
68 if (base == 1) {
69 return 1;
70 } else if (exp <= 2) {
71 return 3;
72 } else {
73 /*
74 base = mant * 2^E,E = bits(base)-1,mant in [1,2]。
75 base^exp 的位数为 exp*log2(mant) + exp*E:
76 整数部分 exp*E 走整数运算;log2 仅作用于 [1,2] 区间
77 (ulp为2^-52,完整保留53位有效数字),exp 提取高53位并
78 向上舍入为double,保证转换不引入低估。
79 */
80 int bits = lmmp_limb_bits_(base);
81 double mant;
82 if (bits <= 53) {
83 mant = ldexp((double)base, 1 - bits);
84 } else {
85 // 高53位无条件进位:base < h*2^(bits-53)
86 uint64_t h = (base >> (bits - 53)) + 1;
87 mant = ldexp((double)h, -52); // in (1,2]
88 }
89 double expd = ulong_upper_d(exp);
90 mp_size_t rn = floor1_u64(expd * log2(mant));
91 if (rn == MP_SIZE_MAX) {
92 return rn;
93 }
94 mp_size_t l = floor1_u64(expd * (double)(bits - 1));
95 if (l == MP_SIZE_MAX) {
96 return l;
97 }
98 rn += l;
99 return (rn + LIMB_BITS - 1) / LIMB_BITS + 2;
100 }
101}
#define MP_SIZE_MAX
static mp_size_t floor1_u64(double r)
计算floor(r)+1并转为mp_size_t
定义 pow.c:58
static double ulong_upper_d(ulong x)
Copyright (C) 2026 HJimmyK (Jericho Knox)
定义 pow.c:40

引用了 floor1_u64(), LIMB_BITS, lmmp_limb_bits_, lmmp_param_assert, lmmp_pow_1_size_(), MP_SIZE_MAX , 以及 ulong_upper_d().

被这些函数引用 check_pow1_agree(), check_pow1_laws(), lmmp_nCr_size_(), lmmp_nPr_size_(), lmmp_pow_1_size_(), lmmp_pow_size_(), lmmp_powmod_() , 以及 pow_nPr_().

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

◆ lmmp_pow_basecase_()

mp_size_t lmmp_pow_basecase_ ( mp_ptr dst,
mp_size_t rn,
mp_srcptr base,
mp_size_t n,
ulong exp )

计算奇数次幂算法 [dst,rn] = [base,n] ^ exp

参数
dst结果指针
rn结果指针的 limb 缓冲区长度
base底数指针
n底数指针的 limb 长度
exp指数
警告
n>0, base[n-1]!=0, sep(dst,base), [base,n]>1, exp>=3, exp%2==1
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API, lmmp_pow_basecase_() , 以及 n.

被这些函数引用 lmmp_pow_(), lmmp_pow_basecase_(), lmmp_pow_basecase_() , 以及 TEST_CASE().

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

◆ lmmp_pow_size_()

mp_size_t lmmp_pow_size_ ( mp_srcptr base,
mp_size_t n,
ulong exp )

计算幂次方需要的limb缓冲区长度 [base,n] ^ exp

参数
base底数指针
n底数 limb 长度
exp指数
警告
n>0, base[n-1]!=0, [base,n]>1
返回
返回值为 [base,n]^exp 需要的 limb 缓冲区长度(比实际长度多)

在文件 pow.c 第 103 行定义.

103 {
104 lmmp_param_assert(n > 0);
105 lmmp_param_assert(base[n - 1] != 0);
106 if (n == 1) {
107 return lmmp_pow_1_size_(base[0], exp);
108 }
109 if (exp == 1) {
110 return n;
111 } else if (exp == 2) {
112 return n * 2;
113 } else {
114 /*
115 直接提取base的最高53位为h(无条件进位,base < h*2^sh,
116 sh为被舍弃的低位位数),mant = h*2^-52 in (1,2],
117 E = bits(base)-1 = sh+52 为log2的整数部分。
118 base^exp 的位数为 exp*log2(mant) + exp*E:
119 整数部分 exp*E 走整数运算;log2 仅作用于 (1,2] 区间,
120 完整保留53位有效数字;exp 提取高53位并向上舍入为double。
121 */
122 int t = lmmp_limb_bits_(base[n - 1]);
123 uint64_t h;
124 if (t >= 53) {
125 h = (base[n - 1] >> (t - 53)) + 1;
126 } else {
127 // n >= 2 必然成立(单limb已在前面处理)
128 h = ((base[n - 1] << (53 - t)) | (base[n - 2] >> (LIMB_BITS - 53 + t))) + 1;
129 }
130 mp_bitcnt_t e_int = (n - 1) * LIMB_BITS + t - 1;
131
132 double expd = ulong_upper_d(exp);
133 mp_size_t rn = floor1_u64(expd * log2(ldexp((double)h, -52)));
134 if (rn == MP_SIZE_MAX) {
135 return rn;
136 }
137 mp_size_t l = floor1_u64(expd * (double)e_int);
138 if (l == MP_SIZE_MAX) {
139 return l;
140 }
141 rn += l;
142 rn = (rn + LIMB_BITS - 1) / LIMB_BITS;
143 return rn + 2;
144 }
145}
mp_size_t lmmp_pow_1_size_(mp_limb_t base, ulong exp)
计算幂次方需要的limb缓冲区长度 base ^ exp
定义 pow.c:65

引用了 floor1_u64(), LIMB_BITS, lmmp_limb_bits_, lmmp_param_assert, lmmp_pow_1_size_(), lmmp_pow_size_(), MP_SIZE_MAX, n, t , 以及 ulong_upper_d().

被这些函数引用 lmmp_pow_(), lmmp_pow_size_(), lmmp_powmod_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_pow_win2_()

mp_size_t lmmp_pow_win2_ ( mp_ptr dst,
mp_size_t rn,
mp_srcptr base,
mp_size_t n,
ulong exp )

计算幂次方2比特窗口快速幂算法 [dst,rn] = [base,n] ^ exp

参数
dst结果指针
rn结果指针的 limb 长度
base底数指针
n底数指针的 limb 长度
exp指数
警告
n>0, base[n-1]!=0, sep(dst,base), exp>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API, lmmp_pow_win2_() , 以及 n.

被这些函数引用 lmmp_pow_(), lmmp_pow_win2_(), lmmp_pow_win2_() , 以及 TEST_CASE().

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

◆ lmmp_powlo_()

void lmmp_powlo_ ( mp_ptr dst,
mp_srcptr bp,
mp_size_t n,
mp_srcptr ep,
mp_size_t en )

计算 [bp,n]^[ep,en] mod B^n,并将结果写入 [dst,n]

参数
dst结果指针(长度为 n 个limb)
bp底数指针
n底数的 limb 长度
ep指数指针
en指数的 limb 长度
警告
dst!=NULL, bp!=NULL, ep!=NULL, en>0, n>0, ep[en-1]>0, sep(dst,[bp|ep])

引用了 LMMP_API, lmmp_powlo_() , 以及 n.

被这些函数引用 bench_powlo(), lmmp_powlo_(), lmmp_powlo_(), lmmp_powmod_() , 以及 TEST_CASE().

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

◆ lmmp_powlo_1_()

void lmmp_powlo_1_ ( mp_ptr dst,
mp_srcptr bp,
mp_srcptr ep,
mp_size_t en )

计算 [bp,1]^[ep,en] mod B,并将结果写入 [dst,1](lmmp_powlo_ 的 1 limb 特化)

参数
dst结果指针(长度为 1 个limb)
bp底数指针(长度为 1 个limb)
ep指数指针
en指数的 limb 长度
警告
dst!=NULL, bp!=NULL, ep!=NULL, en>0, ep[en-1]>0, sep(dst,[bp|ep])
注解
指数为 1 时直接截断取 [bp,1];单 limb 乘法 mod B 即自然回绕, 全程无归约开销

引用了 LMMP_API , 以及 lmmp_powlo_1_().

被这些函数引用 lmmp_powlo_(), lmmp_powlo_1_(), lmmp_powlo_1_() , 以及 TEST_CASE().

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

◆ lmmp_powlo_2_()

void lmmp_powlo_2_ ( mp_ptr dst,
mp_srcptr bp,
mp_srcptr ep,
mp_size_t en )

计算 [bp,2]^[ep,en] mod B^2,并将结果写入 [dst,2](lmmp_powlo_ 的 2 limb 特化)

参数
dst结果指针(长度为 2 个limb)
bp底数指针(长度为 2 个limb)
ep指数指针
en指数的 limb 长度
警告
dst!=NULL, bp!=NULL, ep!=NULL, en>0, ep[en-1]>0, sep(dst,[bp|ep])
注解
指数为 1 时直接截断取 [bp,2];乘法与平方均走 longlong.h 的 128 位低位积内联(_umul128to128_),全程无归约开销

引用了 LMMP_API , 以及 lmmp_powlo_2_().

被这些函数引用 lmmp_powlo_(), lmmp_powlo_2_(), lmmp_powlo_2_() , 以及 TEST_CASE().

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

◆ lmmp_powmod_()

void lmmp_powmod_ ( mp_ptr dst,
mp_srcptr bp,
mp_srcptr ep,
mp_size_t en,
mp_srcptr mp,
mp_size_t n )

计算任意模数模幂 [dst,n] = [bp,n]^[ep,en] % [mp,n]

参数
dst结果指针(长度为 n 个limb,规范剩余 < [mp,n],高位可能为 0)
bp底数指针(长度为 n 个limb)
ep指数指针
en指数的 limb 长度
mp模数指针(长度为 n 个limb,奇偶皆可)
n模数的 limb 长度
警告
dst!=NULL, bp!=NULL, ep!=NULL, mp!=NULL, en>0, ep[en-1]>0, n>0, mp[n-1]>0, [mp,n]>1, [bp,n]<[mp,n], sep(dst,[bp|ep|mp])

引用了 k, LMMP_API, lmmp_is_prime_2_(), lmmp_is_prime_2_notrial_(), lmmp_is_prime_n_(), lmmp_is_prime_n_notrial_(), lmmp_is_prime_uint_(), lmmp_is_prime_ulong_(), lmmp_is_prime_ulong_notrial_(), lmmp_is_prothprime_(), lmmp_is_strong_lucas_(), lmmp_next_prime_ulong_(), lmmp_pow_1_size_(), lmmp_pow_size_(), lmmp_powmod_(), lmmp_prev_prime_ulong_(), lo , 以及 n.

被这些函数引用 bench_powmod_even(), lmmp_powmod_(), lmmp_powmod_(), proth_cert_g(), proth_certified(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_powmod_1_()

void lmmp_powmod_1_ ( mp_ptr dst,
mp_srcptr bp,
mp_srcptr ep,
mp_size_t en,
mp_limb_t mod )

计算奇模数模幂 [dst,1] = [bp,1]^[ep,en] % mod

参数
dst结果指针(长度为 1 个limb)
bp底数指针(长度为 1 个limb)
ep指数指针
en指数的 limb 长度
mod模数
警告
dst!=NULL, bp!=NULL, ep!=NULL, en>0, ep[en-1]>0, mod%2==1, mod>1, [bp,1]<mod

引用了 LMMP_API , 以及 lmmp_powmod_1_().

被这些函数引用 lmmp_powmod_1_(), lmmp_powmod_1_(), lmmp_powmod_odd_() , 以及 TEST_CASE().

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

◆ lmmp_powmod_2_()

void lmmp_powmod_2_ ( mp_ptr dst,
mp_srcptr bp,
mp_srcptr ep,
mp_size_t en,
mp_srcptr mod )

计算奇模数模幂 [dst,2] = [bp,2]^[ep,en] % [mod,2]

参数
dst结果指针(长度为 2 个limb)
bp底数指针(长度为 2 个limb)
ep指数指针
en指数的 limb 长度
mod模数指针(长度为 2 个limb)
警告
dst!=NULL, bp!=NULL, ep!=NULL, mod!=NULL, en>0, ep[en-1]>0, mod[0]%2==1, mod[1]!=0, [mod,2]>1, [bp,2]<[mod,2]

引用了 LMMP_API , 以及 lmmp_powmod_2_().

被这些函数引用 lmmp_powmod_2_(), lmmp_powmod_2_(), lmmp_powmod_odd_() , 以及 TEST_CASE().

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

◆ lmmp_powmod_odd_()

void lmmp_powmod_odd_ ( mp_ptr dst,
mp_srcptr bp,
mp_srcptr ep,
mp_size_t en,
mp_srcptr mp,
mp_size_t n )

计算奇模数模幂 [dst,n] = [bp,n]^[ep,en] % [mp,n]

参数
dst结果指针(长度为 n 个limb,规范剩余 < [mp,n],高位可能为 0)
bp底数指针(长度为 n 个limb)
ep指数指针
en指数的 limb 长度
mp模数指针(长度为 n 个limb)
n模数的 limb 长度
警告
dst!=NULL, bp!=NULL, ep!=NULL, mp!=NULL, en>0, ep[en-1]>0, n>0, mp[0]%2==1, mp[n-1]>0, [mp,n]>1, [bp,n]<[mp,n], sep(dst,[bp|ep|mp])

引用了 LMMP_API, lmmp_powmod_odd_() , 以及 n.

被这些函数引用 bench_powmod_odd(), lmmp_powmod_(), lmmp_powmod_odd_(), lmmp_powmod_odd_(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_powmod_uint_odd_()

uint lmmp_powmod_uint_odd_ ( uint base,
ulong exp,
uint mod )

计算 base^exp 对 mod 取模

参数
base底数
exp指数
mod模数
警告
base<mod, mod>1, mod%2==1
返回
base^exp 对 mod 取模的结果

在文件 powmod_ulong.c 第 94 行定义.

94 {
95 lmmp_param_assert(mod > base);
96 lmmp_param_assert(mod % 2 == 1);
97 lmmp_param_assert(mod > 1);
98 ulong dst = 1;
99 ulong b = base;
100 _udiv64_t binv = _udiv64_gen(mod);
101 ulong q;
102 while (1) {
103 if (exp & 1) {
104 dst *= b;
105 q = _udiv64by64_q_preinv(dst, &binv);
106 dst -= q * mod;
107 }
108 exp >>= 1;
109 if (exp == 0)
110 break;
111 b *= b;
112 q = _udiv64by64_q_preinv(b, &binv);
113 b -= q * mod;
114 }
115 return dst;
116}
static _udiv64_t _udiv64_gen(uint64_t d)
static uint64_t _udiv64by64_q_preinv(uint64_t numer, const _udiv64_t *denom)

引用了 _udiv64_gen(), _udiv64by64_q_preinv(), lmmp_param_assert , 以及 lmmp_powmod_uint_odd_().

被这些函数引用 lmmp_mulmod_ulong_(), lmmp_powmod_uint_odd_(), lmmp_powmod_ulong_odd_() , 以及 TEST_CASE().

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

◆ lmmp_powmod_ulong_odd_()

ulong lmmp_powmod_ulong_odd_ ( ulong base,
ulong exp,
ulong mod )

计算 base^exp 对 mod 取模

参数
base底数
exp指数
mod模数
警告
base<mod, mod>1, mod%2==1
返回
base^exp 对 mod 取模的结果

在文件 powmod_ulong.c 第 118 行定义.

118 {
119 lmmp_param_assert(mod > base);
120 lmmp_param_assert(mod % 2 == 1);
121 lmmp_param_assert(mod > 1);
122 if (mod <= MP_UINT_MAX)
123 return lmmp_powmod_uint_odd_(base, exp, mod);
124 else if (mod <= MONT63_MAX) {
125 ulong R2 = mont63_R2(mod);
126 ulong m_inv = lmmp_binvert_ulong_(mod);
127 m_inv = -m_inv;
128 ulong dst = to_mont63(1, R2, mod, m_inv);
129 base = to_mont63(base, R2, mod, m_inv);
130 while (1) {
131 if (exp & 1)
132 dst = mont63_mul(dst, base, mod, m_inv);
133 exp >>= 1;
134 if (exp == 0)
135 break;
136 base = mont63_mul(base, base, mod, m_inv);
137 }
138 return from_mont63(dst, mod, m_inv);
139 } else {
140 ulong R2 = mont64_R2(mod);
141 ulong m_inv = lmmp_binvert_ulong_(mod);
142 m_inv = -m_inv;
143 ulong dst = to_mont64(1, R2, mod, m_inv);
144 base = to_mont64(base, R2, mod, m_inv);
145 while (1) {
146 if (exp & 1)
147 dst = mont64_mul(dst, base, mod, m_inv);
148 exp >>= 1;
149 if (exp == 0)
150 break;
151 base = mont64_mul(base, base, mod, m_inv);
152 }
153 return from_mont64(dst, mod, m_inv);
154 }
155}
static ulong mont63_mul(ulong a, ulong b, ulong m, ulong m_inv)
static ulong mont64_mul(ulong a, ulong b, ulong m, ulong m_inv)
uint lmmp_powmod_uint_odd_(uint base, ulong exp, uint mod)
计算 base^exp 对 mod 取模
static ulong from_mont64(ulong x, ulong m, ulong m_inv)
static ulong from_mont63(ulong x, ulong m, ulong m_inv)

引用了 from_mont63(), from_mont64(), lmmp_binvert_ulong_(), lmmp_param_assert, lmmp_powmod_uint_odd_(), lmmp_powmod_ulong_odd_(), MONT63_MAX, mont63_mul(), mont63_R2(), mont64_mul(), mont64_R2(), MP_UINT_MAX, to_mont63() , 以及 to_mont64().

被这些函数引用 lmmp_mulmod_ulong_(), lmmp_powmod_ulong_odd_() , 以及 TEST_CASE().

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

◆ lmmp_prev_prime_ulong_()

ulong lmmp_prev_prime_ulong_ ( ulong n)

小于等于n的上一个素数

参数
n起始点(含)
警告
如果 n 小于2,则返回 0
返回
小于等于n的上一个素数,如果n恰好为素数,则返回 n

在文件 is_prime_ulong.c 第 397 行定义.

397 {
398 if (n < ULONG_PRIME_MIN) {
399 return 0;
400 } else if (n < PRIME_SHORT_TABLE_N) {
402 return prime_short_table[idx - 1];
403 } else {
404 n -= (n % 2 == 0) ? 1 : 0;
405 while (1) {
406 if (trial_div16(n)) {
407 n -= 2;
408 } else {
410 return n;
411 } else {
412 n -= 2;
413 }
414 }
415 }
416 }
417}
#define ULONG_PRIME_MIN
#define PRIME_SHORT_TABLE_N

引用了 lmmp_is_prime_ulong_notrial_(), lmmp_prev_prime_ulong_(), lmmp_prime_cnt16_(), n, prime_short_table, PRIME_SHORT_TABLE_N, trial_div16() , 以及 ULONG_PRIME_MIN.

被这些函数引用 lmmp_powmod_(), lmmp_prev_prime_ulong_() , 以及 TEST_CASE().

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

◆ lmmp_primefac_()

mp_size_t lmmp_primefac_ ( mp_ptr dst,
mp_size_t rn,
uint n )

计算质数阶乘(不超过n的质数累乘)

参数
dst结果指针
rn结果指针的 limb 长度
n质数阶乘的阶数
警告
dst!=NULL, rn>0
返回
dst 的实际 limb 长度

引用了 LMMP_API, lmmp_primefac_() , 以及 n.

被这些函数引用 lmmp_primefac_(), lmmp_primefac_(), small_factor_q() , 以及 TEST_CASE().

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

◆ lmmp_primefac_size_()

mp_size_t lmmp_primefac_size_ ( uint n)

计算质数阶乘的 limb 缓冲区长度

参数
n质数阶乘的阶数
返回
质数阶乘的 limb 缓冲区长度

在文件 factorial_extra.c 第 446 行定义.

446 {
447 // Chebyshev's estimate
448 // pn# < exp(1.000028*n)
449 const double log2 = 0.69314718055994531; // log(2)
450 double l = 1.000028 * (double)n;
451 l /= log2;
452 mp_size_t rn = (mp_size_t)ceil(l);
453 rn = (rn + LIMB_BITS - 1) / LIMB_BITS + 2; // more two limbs
454 return rn;
455}

引用了 LIMB_BITS, lmmp_primefac_size_() , 以及 n.

被这些函数引用 lmmp_primefac_size_(), lmmp_superfac_(), small_factor_q() , 以及 TEST_CASE().

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

◆ lmmp_redc_()

mp_limb_t lmmp_redc_ ( mp_ptr dst,
mp_srcptr tp,
mp_srcptr ninv,
mp_srcptr mp,
mp_size_t n )

Montgomery 归约(REDC):计算 ([tp,2n] + q*[mp,n]) / B^n,其中 q = [tp,n] * [ninv,n] mod B^n,即结果为 [tp,2n] * B^(-n) % [mp,n]

参数
dst结果指针(长度为 n 个limb)
tp被归约数指针(长度为 2n 个limb)
ninv-[mp,n]^(-1) mod B^n(长度为 n 个limb)
mp模数指针(长度为 n 个limb)
n模数的 limb 长度
警告
dst!=NULL, tp!=NULL, ninv!=NULL, mp!=NULL, n>0, mp[0]%2==1, mp[n-1]>0, [ninv,n] == -[mp,n]^(-1) mod B^n, sep(dst,[tp|ninv|mp]), [tp,2n] < B^n*[mp,n]
返回
结果最高位(第 n+1 limb 的值,[0|1]),返回值:[dst,n] 即归约结果,且结果 < 2*[mp,n]
注解
典型用法(蒙域乘法):a_m = a*B^n mod m 与 b_m = b*B^n mod m(均 < m)的 全积 [tp,2n] = a_m*b_m 经本函数得 (a*b)*B^n mod m(仍在蒙域),随后若 结果 >= m 再减一次 m 即得 < m 的规范蒙域剩余。 注意:对普通整数 a、b 的全积直接调用得到的是 a*b*B^(-n) mod m(带 Montgomery 缩放因子,条件减法不能将其消去),并非 a*b mod m;如需单次 REDC 完成普通模乘,一操作数取普通域、另一取蒙域:REDC(a*b_m) = a*b mod m

引用了 LMMP_API, lmmp_redc_(), n , 以及 tp.

被这些函数引用 lmmp_redc_(), lmmp_redc_() , 以及 TEST_CASE().

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

◆ lmmp_remove_()

mp_size_t lmmp_remove_ ( mp_ptr np,
mp_size_t * nn,
mp_srcptr dp,
mp_size_t dn )

除去 [np,nn] 中的 [dp,dn] 的因子

参数
np被除数指针,将会被修改为除去因子后的数
nn被除数指针的 limb 长度,将会被修改除去因子后的长度
dp除数指针
dn除数指针的 limb 长度
警告
np!=NULL, nn>0, dp!=NULL, dn>0, [dp,dn]!=1
注解
如果[np,nn]能被[dp,dn]整除,则[np,nn]将被修改为除去因子后的数,nn将被修改为除去因子后的长度。 如果不能被整除,则[np,nn]保持不变,并返回0。
返回
[np,nn]中被[dp,dn]除去的因子的个数,如果不能被整除,则返回0

引用了 LMMP_API, lmmp_remove_(), lmmp_sqrt_1_(), lmmp_sqrt_2_(), lmmp_sqrt_3_(), lmmp_sqrt_4_() , 以及 lmmp_sqrt_ulong_().

被这些函数引用 lmmp_remove_(), lmmp_remove_() , 以及 TEST_CASE().

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

◆ lmmp_sqrt_()

void lmmp_sqrt_ ( mp_ptr dsts,
mp_ptr dstr,
mp_srcptr numa,
mp_size_t na,
mp_size_t nf )

计算 [numa,na] * B^(2*nf) 的平方根和余数

参数
dsts平方根结果输出指针(长度为 nf+na/2+1 个limb)
dstr余数结果输出指针(NULL表示不计算余数)
numa源操作数指针(长度为 na 个limb)
na操作数的 limb 长度
nf精度因子
注解
if (dstr != NULL) { [dsts,nf+na/2+1], [dstr,nf+na/2+1] = sqrtrem([numa,na]*B^(2*nf)) } else { if (nf == 0) { [dsts,na/2+1] = floor(sqrt([numa,na])) } else { [dsts,nf+na/2+1] = [floor|round](sqrt([numa,na]*B^(2*nf))) } }
注意
如你需要精确的floor(sqrt(x))语义,请确保nf==0
警告
na>0, numa[na-1]!=0, eqsep(dsts,numa), eqsep(dstr,numa)

在文件 sqrt.c 第 441 行定义.

441 {
442 lmmp_debug_assert(na > 0);
443 lmmp_debug_assert(numa[na - 1] > 0);
444 mp_limb_t high = numa[na - 1];
445 int nsh = lmmp_leading_zeros_(high) / 2;
446 mp_size_t nl = na + 2 * nf;
447 if (nl == 1) {
448 mp_limb_t r;
449 mp_limb_t srt = lmmp_sqrt_1_(&r, high << nsh * 2);
450 srt >>= nsh;
451 dsts[0] = srt;
452 if (dstr)
453 dstr[0] = high - srt * srt;
454 } else if (nl <= 4) {
455 mp_limb_t tmp[4], rr[3], s, t, b;
456 mp_ptr src = (mp_ptr)numa;
457
458 if (nf) {
459 lmmp_zero(tmp, 2 * nf);
460 lmmp_shl_(tmp + 2 * nf, numa, na, 2 * nsh); // nsh=0 时函数内即整段拷贝
461 src = tmp;
462 } else if (nsh) {
463 lmmp_shl_(tmp, numa, na, 2 * nsh);
464 src = tmp;
465 }
466
467 if (nl == 2) {
468 s = lmmp_sqrt_2_(rr, src);
469 if (dstr && nsh) {
470 // rr[0..1] += 2*t*s - t^2
471 t = s & (((mp_limb_t)1 << nsh) - 1);
472 rr[1] += lmmp_addmul_1_(rr, &s, 1, 2 * t);
473 b = lmmp_submul_1_(rr, &t, 1, t);
474 lmmp_sub_1_(rr + 1, rr + 1, 1, b);
475 }
476 dsts[0] = s >> nsh;
477 dsts[1] = 0;
478 if (dstr)
479 lmmp_shr_(dstr, rr, 2, 2 * nsh);
480 } else if (nl == 3) {
481 lmmp_sqrt_3_(dsts, dstr ? rr : NULL, src);
482 if (dstr && nsh) {
483 // rr[0..2] += 2*t*[dsts,2] - t^2
484 t = dsts[0] & (((mp_limb_t)1 << nsh) - 1);
485 rr[2] += lmmp_addmul_1_(rr, dsts, 2, 2 * t);
486 b = lmmp_submul_1_(rr, &t, 1, t);
487 lmmp_sub_1_(rr + 1, rr + 1, 2, b);
488 }
489 if (nsh)
490 lmmp_shr_(dsts, dsts, 2, nsh);
491 if (dstr) {
492 lmmp_shr_(rr, rr, 3, 2 * nsh);
493 lmmp_copy(dstr, rr, 2);
494 }
495 } else {
496 lmmp_sqrt_4_(dsts, dstr ? rr : NULL, src);
497 if (dstr && nsh) {
498 // rr[0..2] += 2*t*[dsts,2] - t^2
499 t = dsts[0] & (((mp_limb_t)1 << nsh) - 1);
500 rr[2] += lmmp_addmul_1_(rr, dsts, 2, 2 * t);
501 b = lmmp_submul_1_(rr, &t, 1, t);
502 lmmp_sub_1_(rr + 1, rr + 1, 2, b);
503 }
504 dsts[2] = 0;
505 if (nsh)
506 lmmp_shr_(dsts, dsts, 2, nsh);
507 if (dstr)
508 lmmp_shr_(dstr, rr, 3, 2 * nsh);
509 }
510 } else if (!dstr && nf >= SQRT_INVNEWTON_K_THRESHOLD * na) {
511 lmmp_sqrt_newton_(dsts, numa, na, nf);
512 } else {
513 TEMP_DECL;
514 mp_limb_t ns = (nl + 1) / 2;
515 mp_ptr restrict numa2 = TALLOC_TYPE(2 * ns, mp_limb_t);
516 mp_ptr restrict tp = TALLOC_TYPE(3 * ns / 2 + 1, mp_limb_t);
517 lmmp_zero(numa2, 2 * nf);
518 lmmp_shl_(numa2 + 2 * ns - na, numa, na, nsh * 2); // nsh=0 时函数内即整段拷贝
519 if (nl & 1) {
520 numa2[2 * nf] = 0;
521 nsh += LIMB_BITS / 2;
522 } else {
523 dsts[ns] = 0;
524 }
525
526 lmmp_sqrt_divide_(dsts, numa2, ns, tp, dstr ? 1: 0);
527 if (nsh) {
528 /*
529 let
530 s = sqrt(A*T^2), r = sqrtrem(A*T^2)
531 such that
532 s = T*a + t, where a = sqrt(A) = s // T
533 then
534 sqrtrem(A) = (r + 2*T*a*t + t^2) // T^2
535 = (r + 2*t*(s-t) + t^2) // T^2
536 = (r + 2*t*s - t^2) // T^2
537 */
538 if (dstr) {
539 mp_limb_t t = dsts[0] & (((mp_limb_t)1 << nsh) - 1);
540 numa2[ns] += lmmp_addmul_1_(numa2, dsts, ns, 2 * t);
541 mp_limb_t b = lmmp_submul_1_(numa2, &t, 1, t);
542 lmmp_sub_1_(numa2 + 1, numa2 + 1, ns, b);
543 }
544 lmmp_shr_(dsts, dsts, ns, nsh);
545 }
546 if (dstr) {
547 nsh *= 2;
548 if (nsh >= LIMB_BITS) {
549 nsh -= LIMB_BITS;
550 ++numa2;
551 } else
552 ++ns;
553 lmmp_shr_(dstr, numa2, ns, nsh); // nsh=0 时函数内即整段拷贝
554 }
555
556 TEMP_FREE;
557 }
558}
#define lmmp_leading_zeros_
#define tmp
#define SQRT_INVNEWTON_K_THRESHOLD
Copyright (C) 2026 HJimmyK (Jericho Knox)
void lmmp_sqrt_3_(mp_ptr dsts, mp_ptr dstr, mp_srcptr numa)
计算算术平方根 floor(sqrt([numa,3]))
void lmmp_sqrt_newton_(mp_ptr dsts, mp_srcptr numa, mp_size_t na, mp_size_t nf)
计算近似平方根 [dsts,nf+na/2+1]=[floor|round](sqrt([numa,na]*B^(2*nf)))
定义 sqrt.c:392
void lmmp_sqrt_divide_(mp_ptr dst, mp_ptr numa, mp_size_t ns, mp_ptr tp, int calr)
计算算术平方根 floor(sqrt([numa,2*ns]))
mp_limb_t lmmp_sqrt_1_(mp_ptr dstr, mp_limb_t x)
计算算术平方根 floor(sqrt(x))
mp_limb_t lmmp_sqrt_2_(mp_ptr dstr, mp_srcptr numa)
计算算术平方根 floor(sqrt([numa,2]))
void lmmp_sqrt_4_(mp_ptr dsts, mp_ptr dstr, mp_srcptr numa)
计算算术平方根 floor(sqrt([numa,4]))

引用了 LIMB_BITS, lmmp_addmul_1_(), lmmp_copy, lmmp_debug_assert, lmmp_leading_zeros_, lmmp_shl_(), lmmp_shr_(), lmmp_sqrt_(), lmmp_sqrt_1_(), lmmp_sqrt_2_(), lmmp_sqrt_3_(), lmmp_sqrt_4_(), lmmp_sqrt_divide_(), lmmp_sqrt_newton_(), lmmp_sub_1_(), lmmp_submul_1_(), lmmp_zero, restrict, s, SQRT_INVNEWTON_K_THRESHOLD, t, TALLOC_TYPE, TEMP_DECL, TEMP_FREE, tmp , 以及 tp.

被这些函数引用 bench_sqrt(), lmmp_invsqrt_newton_(), lmmp_nthroot_(), lmmp_perfsqr_(), lmmp_sqrt_(), TEST_CASE(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_sqrt_1_()

mp_limb_t lmmp_sqrt_1_ ( mp_ptr dstr,
mp_limb_t x )

计算算术平方根 floor(sqrt(x))

参数
dstr余数指针(1个limb)
x被开方数
警告
x>=B/4, dstr!=NULL
注解
[dstr,1]=sqrtrem(x), return floor(sqrt(x))
返回
floor(sqrt(x))

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

42 {
45 *dstr = x - s * s;
46 return s;
47}
#define LIMB_B_4

引用了 LIMB_B_4, lmmp_param_assert, lmmp_sqrt_1_(), lmmp_sqrt_ulong_() , 以及 s.

被这些函数引用 lmmp_remove_(), lmmp_sqrt_(), lmmp_sqrt_1_(), lmmp_sqrt_2_() , 以及 TEST_CASE().

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

◆ lmmp_sqrt_2_()

mp_limb_t lmmp_sqrt_2_ ( mp_ptr dstr,
mp_srcptr numa )

计算算术平方根 floor(sqrt([numa,2]))

参数
dstr余数指针(2个limb)
numa被开方数指针
警告
numa[1]>=B/4, dstr!=NULL, numa!=NULL, eqsep(dstr,numa)
注解
return: floor(sqrt([numa,2])), [dstr,2]=remainder
返回
floor(sqrt([numa,2]))

在文件 sqrt_1.c 第 49 行定义.

49 {
50 lmmp_param_assert(numa[1] >= LIMB_B_4);
51 mp_limb_t rl, s, q, al, u;
52 mp_slimb_t rh;
53
54 s = lmmp_sqrt_1_(&rl, numa[1]);
55 al = numa[0];
56
57 //(r:alh)/2
58 rl = rl << 31 | al >> 33;
59 q = rl / s;
60 q -= q >> 32;
61
62 u = rl - s * q;
63 s = s << 32 | q;
64 rh = u >> 31;
65 rl = (u << 33) | (al & (((mp_limb_t)1 << 33) - 1));
66
67 q *= q;
68 rh -= rl < q;
69 rl -= q;
70 if (rh < 0) {
71 rl += s;
72 rh += rl < s;
73 --s;
74 rl += s;
75 rh += rl < s;
76 }
77
78 dstr[0] = rl;
79 dstr[1] = rh;
80 return s;
81}
int64_t mp_slimb_t
定义 lmmp.h:94

引用了 LIMB_B_4, lmmp_param_assert, lmmp_sqrt_1_(), lmmp_sqrt_2_() , 以及 s.

被这些函数引用 is_square_2(), lmmp_remove_(), lmmp_sqrt_(), lmmp_sqrt_2_(), lmmp_sqrt_3_(), lmmp_sqrt_4_(), lmmp_sqrt_divide_() , 以及 TEST_CASE().

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

◆ lmmp_sqrt_3_()

void lmmp_sqrt_3_ ( mp_ptr dsts,
mp_ptr dstr,
mp_srcptr numa )

计算算术平方根 floor(sqrt([numa,3]))

参数
dsts结果指针(2个limb)
dstr余数指针(3个limb,最高位补零),传 NULL 表示不计算余数
numa被开方数指针
警告
numa[2]>=B/4, dsts!=NULL, numa!=NULL, eqsep(dsts,numa), eqsep(dstr,numa)
注解
[dstr,3] = [numa,3] - [dsts,2]^2 <= 2*[dsts,2]

在文件 sqrt_1.c 第 98 行定义.

98 {
99 lmmp_param_assert(numa != NULL && dsts != NULL);
100 lmmp_param_assert(numa[2] >= LIMB_B_4);
101 mp_limb_t a0 = numa[0];
102 mp_limb_t rh[2], n1, n0, q, u, uc, s1, s0, r1, r0, p[2], neg;
103
104 // s' = sqrt([a2,a1]) >= 2^63,rh = [a2,a1] - s'^2 <= 2s'
105 mp_limb_t sh = lmmp_sqrt_2_(rh, numa + 1);
106
107 // N = rh*2^32 + (a0>>32) < 2^34*s',N/s' < 2^34,n1 = N>>64 < s'
108 n1 = (rh[1] << 32) | (rh[0] >> 32);
109 n0 = (rh[0] << 32) | (a0 >> 32);
110 mp_limb_t qh = _udiv128by64to64_(n1, n0, sh, &u);
111 // q = N div 2s',(uc,u) = N mod 2s'
112 q = qh >> 1;
113 _add_ssaaaa(uc, u, 0, u, 0, sh & (-(qh & 1)));
114
115 // s = s'*2^32 + q
116 _add_ssaaaa(s1, s0, sh >> 32, sh << 32, 0, q);
117
118 // r = u*2^32 + (a0 & M32) - q^2,|r| < 2^98(双 limb 有符号)
119 lmmp_mullh_(q, q, p);
120 _sub_ddmmss(r1, r0, (uc << 32) | (u >> 32), (u << 32) | (a0 & (((mp_limb_t)1 << 32) - 1)),
121 p[1], p[0]);
122
123 // r < 0(概率约 1/4):s -= 1,r += 2s + 1,(s0<<1)|1 = 2*s0+1 无进位
124 neg = -(r1 >> (LIMB_BITS - 1));
125 _sub_ddmmss(s1, s0, s1, s0, 0, neg & 1);
126 _add_ssaaaa(r1, r0, r1, r0, neg & ((s1 << 1) | (s0 >> (LIMB_BITS - 1))),
127 neg & ((s0 << 1) | 1));
128
129 dsts[0] = s0;
130 dsts[1] = s1;
131 if (dstr != NULL) {
132 dstr[0] = r0;
133 dstr[1] = r1;
134 dstr[2] = 0;
135 }
136}
#define lmmp_mullh_
#define _sub_ddmmss(sh, sl, ah, al, bh, bl)
static uint64_t _udiv128by64to64_(uint64_t numhi, uint64_t numlo, uint64_t den, uint64_t *r)
#define _add_ssaaaa(sh, sl, ah, al, bh, bl)

引用了 _add_ssaaaa, _sub_ddmmss, _udiv128by64to64_(), a0, LIMB_B_4, LIMB_BITS, lmmp_mullh_, lmmp_param_assert, lmmp_sqrt_2_(), lmmp_sqrt_3_(), r0 , 以及 r1.

被这些函数引用 lmmp_remove_(), lmmp_sqrt_(), lmmp_sqrt_3_() , 以及 TEST_CASE().

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

◆ lmmp_sqrt_4_()

void lmmp_sqrt_4_ ( mp_ptr dsts,
mp_ptr dstr,
mp_srcptr numa )

计算算术平方根 floor(sqrt([numa,4]))

参数
dsts结果指针(2个limb)
dstr余数指针(3个limb),传 NULL 表示不计算余数
numa被开方数指针
警告
numa[3]>=B/4, dsts!=NULL, numa!=NULL, eqsep(dsts,numa), eqsep(dstr,numa)
注解
[dstr,3] = [numa,4] - [dsts,2]^2 <= 2*[dsts,2]

在文件 sqrt_1.c 第 138 行定义.

138 {
139 lmmp_param_assert(numa != NULL && dsts != NULL);
140 lmmp_param_assert(numa[3] >= LIMB_B_4);
141 mp_limb_t x0 = numa[0], x1 = numa[1];
142 mp_limb_t rh[2], qh, ql, u, uc, t, s1, s0, r2, r1, r0, p[2], b, neg;
143
144 // s' = sqrt([x3,x2]) >= 2^63,rh = [x3,x2] - s'^2 <= 2s'
145 mp_limb_t sh = lmmp_sqrt_2_(rh, numa + 2);
146
147 // N = rh*B + x1 除以 s':先把顶 limb 归约到 s' 以下(至多两次),商计入学 qh
148 qh = rh[1];
149 rh[0] -= sh & (-(mp_limb_t)(rh[1] != 0));
150 t = (rh[0] >= sh);
151 rh[0] -= sh & (-(mp_limb_t)t);
152 qh += t;
153 ql = _udiv128by64to64_(rh[0], x1, sh, &u);
154
155 // N div s' = qh*B + ql = 2*s_low + (ql&1),N mod 2s' = u + (ql&1)*s'
156 s0 = (ql >> 1) | (qh << (LIMB_BITS - 1));
157 qh >>= 1;
158 _add_ssaaaa(uc, u, 0, u, 0, sh & (-(ql & 1)));
159
160 // r = (uc,u)*B + x0 - s_low^2,s_low = qh*B + s0 <= B(qh=1 时 s0=0)
161 lmmp_mullh_(s0, s0, p);
162 _sub_ddmmss(r1, r0, u, x0, p[1], p[0]);
163 b = (u < p[1]) | ((u == p[1]) & (x0 < p[0]));
164 r2 = uc - qh - b;
165
166 // s = s'*B + s_low;sh = B-1 且 s_low = B 时 s1 回绕为 0,r < 0 修正时解开
167 s1 = sh + qh;
168 neg = -(r2 >> (LIMB_BITS - 1));
169 _sub_ddmmss(s1, s0, s1, s0, 0, neg & 1);
170 // r += 2s + 1:低位 (s0<<1)|1 = 2*s0+1 无进位,进位链并入 r2
171 {
172 mp_limb_t al = neg & ((s0 << 1) | 1);
173 mp_limb_t ah = neg & ((s1 << 1) | (s0 >> (LIMB_BITS - 1)));
174 __uint128_t tc;
175
176 tc = (__uint128_t)r0 + al;
177 r0 = (mp_limb_t)tc;
178 tc = (__uint128_t)r1 + ah + (mp_limb_t)(tc >> 64);
179 r1 = (mp_limb_t)tc;
180 r2 += (neg & (s1 >> (LIMB_BITS - 1))) + (mp_limb_t)(tc >> 64);
181 }
182
183 dsts[0] = s0;
184 dsts[1] = s1;
185 if (dstr != NULL) {
186 dstr[0] = r0;
187 dstr[1] = r1;
188 dstr[2] = r2;
189 }
190}

引用了 _add_ssaaaa, _sub_ddmmss, _udiv128by64to64_(), LIMB_B_4, LIMB_BITS, lmmp_mullh_, lmmp_param_assert, lmmp_sqrt_2_(), lmmp_sqrt_4_(), r0, r1, r2 , 以及 t.

被这些函数引用 lmmp_remove_(), lmmp_sqrt_(), lmmp_sqrt_4_(), lmmp_sqrt_divide_() , 以及 TEST_CASE().

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

◆ lmmp_sqrt_divide_()

void lmmp_sqrt_divide_ ( mp_ptr dst,
mp_ptr numa,
mp_size_t ns,
mp_ptr tp,
int calr )

计算算术平方根 floor(sqrt([numa,2*ns]))

参数
dst结果指针(ns个limb)
numa被开方数指针(2*ns个limb,且会被修改,若计算余数,余数存储在[numa,ns+1]中)
ns结果指针的 limb 长度
tp临时指针(3*ns/2+1个limb)
calr是否计算余数(0表示不计算余数,1表示计算余数)
警告
numa[2*ns-1]>=B/4, dst!=NULL, numa!=NULL, tp!=NULL, sep(dst,numa,tp)
注解
即使输入calr=0,numa也会被修改,如果calr=1,则[numa,ns+1]将会储存余数。

引用了 LMMP_API, lmmp_sqrt_divide_() , 以及 tp.

被这些函数引用 lmmp_invsqrt_newton_(), lmmp_sqrt_(), lmmp_sqrt_divide_(), lmmp_sqrt_divide_() , 以及 TEST_CASE().

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

◆ lmmp_sqrt_newton_()

void lmmp_sqrt_newton_ ( mp_ptr dsts,
mp_srcptr numa,
mp_size_t na,
mp_size_t nf )

计算近似平方根 [dsts,nf+na/2+1]=[floor|round](sqrt([numa,na]*B^(2*nf)))

参数
dsts目标数组(长度为 nf+na/2+1 个limb)
numa输入数组(长度为 na 个limb)
nanuma数组的 limb 长度
nf精度因子
警告
na>0, nf>=2, nf+na/2+1>=na, dsts!=NULL, numa!=NULL, eqsep(dsts,numa)
注解
设 x = sqrt([numa,na]*B^(2*nf))(实数),round 为四舍五入(恰为 1/2 时进位), 则结果恰为 round(x-eps),其中 0 <= eps < 2^-31(na 为奇数)或 2^-63(na 为偶数)。 eps 非负,故结果绝不超过 round(x);仅当 x 的小数部分落在 [1/2, 1/2+eps) 时得到 floor(x) 而非 floor(x)+1(随机输入下概率 < 2^-30),此即 [floor|round] 的确切含义。

在文件 sqrt.c 第 392 行定义.

392 {
393 lmmp_param_assert(na > 0);
394 lmmp_param_assert(nf >= 2);
395 lmmp_param_assert(numa != NULL && dsts != NULL);
396 mp_limb_t high = numa[na - 1];
397 int nsh = lmmp_leading_zeros_(high) / 2;
398 mp_size_t ns = na / 2 + 1 + nf;
399
400 TEMP_DECL;
401 mp_limb_t alloc_size = (nsh ? na : 0) + ns + 1;
402 mp_ptr tp = TALLOC_TYPE(alloc_size, mp_limb_t), numa2;
403 if (nsh) {
404 numa2 = tp;
405 lmmp_shl_(numa2, numa, na, nsh * 2);
406 tp += na;
407 } else
408 numa2 = (mp_ptr)numa;
409
410 lmmp_invsqrt_newton_(tp, ns, numa2, na);
411
412 mp_ptr restrict msqr = TALLOC_TYPE(na + ns + 1, mp_limb_t);
413
414 if (ns + 1 > na)
415 lmmp_mul_(msqr, tp, ns + 1, numa2, na);
416 else
417 lmmp_mul_(msqr, numa2, na, tp, ns + 1);
418
419 mp_limb_t cceil;
420 if (na & 1) {
421 nsh += LIMB_BITS / 2;
422 lmmp_shr_(dsts, msqr + na, ns, nsh);
423 cceil = msqr[na] >> (nsh - 1);
424 } else {
425 if (nsh) {
426 lmmp_shr_(dsts, msqr + na + 1, ns - 1, nsh);
427 cceil = msqr[na + 1] >> (nsh - 1);
428 } else {
429 lmmp_copy(dsts, msqr + na + 1, ns - 1);
430 cceil = msqr[na] >> (LIMB_BITS - 1);
431 }
432 dsts[ns - 1] = 0;
433 }
434
435 if (cceil & 1)
436 lmmp_inc(dsts);
437
438 TEMP_FREE;
439}
void lmmp_invsqrt_newton_(mp_ptr dstis, mp_size_t ns, mp_srcptr numa, mp_size_t na)
计算逆平方根的定点下近似:记 I=floor(sqrt(B^(2*ns+na)/[numa,na])), 则 [dstis,ns+1] 满足 I-1 <= [dstis,...

引用了 LIMB_BITS, lmmp_copy, lmmp_inc, lmmp_invsqrt_newton_(), lmmp_leading_zeros_, lmmp_mul_(), lmmp_param_assert, lmmp_shl_(), lmmp_shr_(), lmmp_sqrt_newton_(), restrict, TALLOC_TYPE, TEMP_DECL, TEMP_FREE , 以及 tp.

被这些函数引用 lmmp_invsqrt_newton_(), lmmp_sqrt_(), lmmp_sqrt_newton_() , 以及 TEST_CASE().

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

◆ lmmp_sqrt_ulong_()

ulong lmmp_sqrt_ulong_ ( ulong a)

计算算术平方根 floor(sqrt(a))

Copyright (C) 2026 HJimmyK (Jericho Knox)

参数
a被开方数
返回
floor(sqrt(a))

计算算术平方根 floor(sqrt(a))

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

在文件 sqrt_1.c 第 31 行定义.

31 {
32 ulong is;
33
34 is = (ulong)sqrt((double)a);
35
36 is -= (is * is > a);
37 if (is == (1ULL << 32))
38 is--;
39 return is;
40}

引用了 lmmp_sqrt_ulong_().

被这些函数引用 lmmp_nthroot_ulong_(), lmmp_remove_(), lmmp_sqrt_1_(), lmmp_sqrt_ulong_(), TEST_CASE() , 以及 TEST_CASE().

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

◆ lmmp_superfac_()

mp_size_t lmmp_superfac_ ( mp_ptr dst,
mp_bitcnt_t bits,
mp_size_t rn,
ushort n )

计算super阶乘(k!

累乘至n)

参数
dst结果指针
bitssuper阶乘的2的因子数
rn结果指针的 limb 长度
nsuper阶乘的阶数
警告
dst!=NULL, rn>0
返回
dst 的实际 limb 长度

引用了 LMMP_API, lmmp_primefac_size_(), lmmp_superfac_() , 以及 n.

被这些函数引用 lmmp_superfac_(), lmmp_superfac_() , 以及 TEST_CASE().

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

◆ lmmp_superfac_size_()

mp_size_t lmmp_superfac_size_ ( ushort n,
mp_bitcnt_t * bits )

计算super阶乘的 limb 缓冲区长度

参数
nsuper阶乘的阶数
bits被修改为 super阶乘的2的因子数
警告
bits!=NULL
返回
super阶乘的 limb 缓冲区长度

引用了 LMMP_API, lmmp_superfac_size_() , 以及 n.

被这些函数引用 lmmp_superfac_size_(), lmmp_superfac_size_() , 以及 TEST_CASE().

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

◆ lmmp_u16_pow_1_()

mp_size_t lmmp_u16_pow_1_ ( mp_ptr dst,
mp_size_t rn,
ulong base,
ulong exp )

计算幂次方 [dst,rn] = [base,1] ^ exp

参数
dst结果指针
rn结果指针的 limb 长度
base底数(16位无符号整数)
exp指数
警告
0<base<=0xffff, exp>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API , 以及 lmmp_u16_pow_1_().

被这些函数引用 _odd_pow_(), lmmp_pow_1_(), lmmp_u16_pow_1_(), lmmp_u16_pow_1_() , 以及 TEST_CASE().

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

◆ lmmp_u32_pow_1_()

mp_size_t lmmp_u32_pow_1_ ( mp_ptr dst,
mp_size_t rn,
ulong base,
ulong exp )

计算幂次方 [dst,rn] = [base,1] ^ exp

参数
dst结果指针
rn结果指针的 limb 长度
base底数(32位无符号整数)
exp指数
警告
0<base<=2^32-1, exp>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API , 以及 lmmp_u32_pow_1_().

被这些函数引用 _odd_pow_(), lmmp_pow_1_(), lmmp_u32_pow_1_(), lmmp_u32_pow_1_() , 以及 TEST_CASE().

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

◆ lmmp_u4_pow_1_()

mp_size_t lmmp_u4_pow_1_ ( mp_ptr dst,
mp_size_t rn,
ulong base,
ulong exp )

计算幂次方 [dst,rn] = [base,1] ^ exp

参数
dst结果指针
rn结果指针的 limb 长度
base底数(4位无符号整数)
exp指数
警告
1<=base<=0xf, exp>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API , 以及 lmmp_u4_pow_1_().

被这些函数引用 _odd_pow_(), lmmp_pow_1_(), lmmp_u4_pow_1_(), lmmp_u4_pow_1_() , 以及 TEST_CASE().

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

◆ lmmp_u64_pow_1_()

mp_size_t lmmp_u64_pow_1_ ( mp_ptr dst,
mp_size_t rn,
ulong base,
ulong exp )

计算幂次方 [dst,rn] = [base,1] ^ exp

参数
dst结果指针
rn结果指针的 limb 长度
base底数(64位无符号整数)
exp指数
警告
2^32<=base<=2^64-1, exp>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API , 以及 lmmp_u64_pow_1_().

被这些函数引用 lmmp_pow_1_(), lmmp_u64_pow_1_(), lmmp_u64_pow_1_() , 以及 TEST_CASE().

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

◆ lmmp_u8_pow_1_()

mp_size_t lmmp_u8_pow_1_ ( mp_ptr dst,
mp_size_t rn,
ulong base,
ulong exp )

计算幂次方 [dst,rn] = [base,1] ^ exp

参数
dst结果指针
rn结果指针的 limb 长度
base底数(8位无符号整数)
exp指数
警告
0<base<=0xff, exp>0
返回
返回 dst 的实际 limb 长度

引用了 LMMP_API , 以及 lmmp_u8_pow_1_().

被这些函数引用 _odd_pow_(), lmmp_pow_1_(), lmmp_u8_pow_1_(), lmmp_u8_pow_1_() , 以及 TEST_CASE().

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