36TEST_CASE(
"numth/number", nPr_nCr_multinomial_arith) {
38 const size_t CAP = 2048;
39 mp_ptr e = alloc_limbs(CAP), f1 = alloc_limbs(CAP), f2 = alloc_limbs(CAP),
40 prod = alloc_limbs(CAP);
41 const ulong n_values[] = {0, 1, 5, 10, 20, 50, 100};
42 for (
size_t n_index = 0; n_index <
ARRAY_SIZE(n_values); ++n_index) {
43 ulong n = n_values[n_index];
44 for (
ulong r = 0; r <=
n; r += (
n > 20 ? 20 : 1)) {
48 for (
u32 i = (
u32)(
n - r + 1); i <=
n; ++i) elen = chain_mul_small(e, elen, i, CAP);
52 mp_ptr dst = alloc_limbs(need + 2);
58 if (r >= 2 &&
n - r >= 1) {
65 mp_size_t l1 = norm_len(f1, need1 + 2), l2 = norm_len(f2, need2 + 2);
67 mul_sorted(
prod, dst, ldst, f2, l2);
77 struct known_result {
u32 n;
u32 r;
u64 v; } known[] = {{10, 5, 252ull}, {52, 5, 2598960ull}};
78 for (
size_t k_index = 0; k_index <
ARRAY_SIZE(known); ++k_index) {
79 const struct known_result
k = known[k_index];
82 mp_ptr dst = alloc_limbs(need + 2);
90 mp_ptr cn = alloc_limbs(CAP), cn1 = alloc_limbs(CAP), cn2 = alloc_limbs(CAP);
91 const u32 n_values2[] = {2, 5, 10, 20, 50};
92 for (
size_t n_index = 0; n_index <
ARRAY_SIZE(n_values2); ++n_index) {
93 u32 n = n_values2[n_index];
94 for (
u32 r = 1; r <=
n / 2; ++r) {
106 mp_size_t l1 = norm_len(cn1, nd1 + 2), l2 = norm_len(cn2, nd2 + 2);
108 mp_ptr pad = alloc_limbs(CAP), sum = alloc_limbs(CAP);
109 size_t mx = (size_t)(l1 > l2 ? l1 : l2) + 1;
111 memcpy(pad, cn1, (
size_t)l1 * 8);
113 memcpy(sum, cn2, (
size_t)l2 * 8);
115 TEST_CHECK(mpn_eq(sum, mx, cn, norm_len(cn, nd0 + 2)));
129 mp_ptr rem = alloc_limbs(nfn + 2);
132 mp_size_t lfr = norm_len(f1, nfr + 2), lfnr = norm_len(f2, nfnr + 2);
133 mp_size_t lcn = norm_len(cn, nd0 + 2), lfn = norm_len(rem, nfn + 2);
134 mp_ptr quot = alloc_limbs(CAP);
135 mul_sorted(
prod, cn, lcn, f1, lfr);
137 mul_sorted(quot,
prod, lp, f2, lfnr);
138 lp = norm_len(quot, lp + lfnr);
155 mp_ptr dst = alloc_limbs(need + 2);
164 const u32 x_values[] = {1, 3, 10};
165 for (
size_t x_index = 0; x_index <
ARRAY_SIZE(x_values); ++x_index) {
166 u32 x = x_values[x_index];
167 const u32 m_values[] = {2, 5, 10};
168 for (
size_t m_index = 0; m_index <
ARRAY_SIZE(m_values); ++m_index) {
169 u32 m = m_values[m_index];
170 const u32 n_values3[] = {1, 3, 10};
171 for (
size_t n_index = 0; n_index <
ARRAY_SIZE(n_values3); ++n_index) {
172 u32 n = n_values3[n_index];
173 if ((
u64)x + (
u64)
n * m > 100000)
continue;
176 for (
u32 i = 0; i <=
n; ++i) elen = chain_mul_small(e, elen, x + i * m, CAP);
178 mp_ptr dst = alloc_limbs(need + 2);
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]
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)