remove.c 文件参考

#include "../../../include/lammp/numth.h"
#include "../../../include/lammp/lmmpn.h"
#include "../../../include/lammp/impl/tmp_alloc.h"

remove.c 的引用(Include)关系图:

浏览源代码.

宏定义
#define	MAX_EXP   48

函数
mp_size_t	lmmp_remove_ (mp_ptr np, mp_size_t *nn, mp_srcptr dp, mp_size_t dn)
	除去[np,nn]中的[dp,dn]的因子
static mp_size_t	try_div_ (mp_ptr qp, mp_ptr rp, mp_srcptr divp, mp_size_t divn, mp_srcptr numb, mp_size_t nb)
	qp 为商，rp 为余数，divp 为被除数，divn 为被除数长度，numb 为除数，nb 为除数长度 如果无法整除，则返回0，否则返回除数 qp 的长度

宏定义说明

MAX_EXP

#define MAX_EXP   48

在文件 remove.c 第 20 行定义.

函数说明

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

注解

如果[np,nn]能被[dp,dn]整除，则[np,nn]将被修改为除去因子后的数，nn将被修改为除去因子后的长度。 如果不能被整除，则[np,nn]保持不变，并返回0。

返回

[np,nn]中被[dp,dn]除去的因子的个数，如果不能被整除，则返回0

在文件 remove.c 第 56 行定义.

                                                                             {
    lmmp_param_assert(np != NULL && *nn > 0);
    lmmp_param_assert(dp != NULL && dn > 0);
 
    mp_srcptr pd_pow[MAX_EXP];
    mp_size_t pn_pow[MAX_EXP];
    // qp as quotient, rp as remainder, divp as divdend
    mp_ptr qp, rp, divp;
    mp_ptr prod;
    mp_size_t divn = *nn, qn;
    mp_size_t ret = 0;
    int i, j;
    pd_pow[0] = dp;
    pn_pow[0] = dn;
 
    TEMP_DECL;
 
    qp = TALLOC_TYPE(*nn, mp_limb_t);
    rp = TALLOC_TYPE(*nn, mp_limb_t);
 
    divp = np;
 
    for (i = 1; i < MAX_EXP; i++) {
        // if qn == 0, means cannot be divided by pd_pow[i - 1]
        if (qn = try_div_(qp, rp, divp, divn, pd_pow[i - 1], pn_pow[i - 1])) {
            divn = qn;
            LMMP_SWAP(qp, divp, mp_ptr);
 
            ret += 1 << (i - 1);
            pn_pow[i] = 2 * pn_pow[i - 1];
            if (divn < pn_pow[i]) {
                ++i;
                break;
            }
            prod = TALLOC_TYPE(pn_pow[i], mp_limb_t);
            lmmp_sqr_(prod, pd_pow[i - 1], pn_pow[i - 1]);
            pn_pow[i] -= (prod[pn_pow[i] - 1] == 0) ? 1 : 0;
            pd_pow[i] = prod;
        } else {
            break;
        }
    }
    for (j = i - 1; j > 0; --j) {
        if (qn = try_div_(qp, rp, divp, divn, pd_pow[j - 1], pn_pow[j - 1])) {
            divn = qn;
            LMMP_SWAP(qp, divp, mp_ptr);
 
            ret += 1 << (j - 1);
        }
    }
    if (qn == 0) {
        // 无法整除
        lmmp_copy(np, divp, divn);
        *nn = divn;
    } else {
        // 整除
        lmmp_copy(np, qp, qn);
        *nn = qn;
    }
 
    TEMP_FREE;
    return ret;
}

引用了 lmmp_copy, lmmp_param_assert, lmmp_sqr_(), LMMP_SWAP, MAX_EXP, TALLOC_TYPE, TEMP_DECL, TEMP_FREE , 以及 try_div_().

函数调用图:

try_div_()

static mp_size_t try_div_ ( mp_ptr  qp, mp_ptr  rp, mp_srcptr  divp, mp_size_t  divn, mp_srcptr  numb, mp_size_t  nb  )

inlinestatic

qp 为商，rp 为余数，divp 为被除数，divn 为被除数长度，numb 为除数，nb 为除数长度 如果无法整除，则返回0，否则返回除数 qp 的长度

在文件 remove.c 第 26 行定义.

                                                                                                                     {
    if (divn < nb) {
        return 0;
    } else {
        int cmp;
        if (divn > nb)
            cmp = 1;
        else
            cmp = lmmp_cmp_(divp, numb, nb);
        if (cmp == 0) {
            qp[0] = 1;
            return 1;
        } else if (cmp < 0) {
            return 0;
        } else {
            // 拷贝原始数，当无法整除时，再进行恢复
            lmmp_div_(qp, rp, divp, divn, numb, nb);
            if (lmmp_zero_q_(rp, nb)) {
                // 整除
                divn = divn - nb + 1;
                while (divn > 0 && qp[divn - 1] == 0) --divn;
                return divn;
            } else {
                // 无法整除
                return 0;
            }
        }
    }
}

引用了 lmmp_cmp_(), lmmp_div_() , 以及 lmmp_zero_q_().

被这些函数引用 lmmp_remove_().

函数调用图:

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