自学教程：C++ FLINT_MAX函数代码示例

void _fmpz_poly_hensel_lift_without_inverse(fmpz *G, fmpz *H,     const fmpz *f, long lenF,     const fmpz *g, long lenG, const fmpz *h, long lenH,     const fmpz *a, long lenA, const fmpz *b, long lenB,     const fmpz_t p, const fmpz_t p1){    const fmpz one[1] = {1l};    const long lenM = FLINT_MAX(lenG, lenH);    const long lenE = FLINT_MAX(lenG + lenB - 2, lenH + lenA - 2);    const long lenD = FLINT_MAX(lenE, lenF);    fmpz *C, *D, *E, *M;    C = _fmpz_vec_init(lenF + lenD + lenE + lenM);    D = C + lenF;    E = D + lenD;    M = E + lenE;    if (lenG >= lenH)        _fmpz_poly_mul(C, g,lenG, h, lenH);    else        _fmpz_poly_mul(C, h, lenH, g, lenG);    _fmpz_vec_sub(C, f, C, lenF);    _fmpz_vec_scalar_divexact_fmpz(D, C, lenF, p);    _fmpz_vec_scalar_mod_fmpz(C, D, lenF, p1);    lift(G, g, lenG, b, lenB);    lift(H, h, lenH, a, lenA);    _fmpz_vec_clear(C, lenF + lenD + lenE + lenM);}

int main(void){    /* Example 3 */    long n = 4;    long d = 6;    long N = 500;    fmpz_t p = {97L};    fmpz a[5] = {1, 2, 3, 4, 5};    padic_ctx_t pctx;    padic_mat_t F;    long i, lenB = gmc_basis_size(n, d);    padic_ctx_init(pctx, p, FLINT_MAX(0, N), N, PADIC_VAL_UNIT);    padic_mat_init2(F, lenB, lenB, N);    diagfrob(F, a, n, d, N, pctx, 1);    padic_mat_print_pretty(F, pctx);    printf("/n/n");    /* Clean-up */    fmpz_clear(p);    padic_mat_clear(F);    padic_ctx_clear(pctx);    return EXIT_SUCCESS;}

voidarb_fprintd(FILE * file, const arb_t x, slong digits){    arf_fprintd(file, arb_midref(x), FLINT_MAX(digits, 1));    flint_fprintf(file, " +/- ");    mag_fprintd(file, arb_radref(x), 5);}

void_hypgeom_precompute(hypgeom_t hyp, const fmpz_poly_t P, const fmpz_poly_t Q){    slong k;    fmpz_t t;    fmpz_init(t);    hyp->r = fmpz_poly_degree(Q) - fmpz_poly_degree(P);    hyp->boundC = hypgeom_root_norm(P);    hyp->boundD = hypgeom_root_norm(Q);    hyp->boundK = 1 + FLINT_MAX(hyp->boundC, 2 * hyp->boundD);    mag_one(hyp->MK);    for (k = 1; k <= hyp->boundK; k++)    {        fmpz_poly_evaluate_si(t, P, k);        mag_mul_fmpz(hyp->MK, hyp->MK, t);        fmpz_poly_evaluate_si(t, Q, k);        mag_div_fmpz(hyp->MK, hyp->MK, t);    }    fmpz_clear(t);}

void padic_poly_sub(padic_poly_t f,                     const padic_poly_t g, const padic_poly_t h,                     const padic_ctx_t ctx){    const slong lenG = g->length;    const slong lenH = h->length;    const slong lenF = FLINT_MAX(lenG, lenH);    if (lenG == 0)    {        padic_poly_neg(f, h, ctx);        return;    }    if (lenH == 0)    {        padic_poly_set(f, g, ctx);        return;    }    if ((lenG == 0 && lenH == 0) || (FLINT_MIN(g->val, h->val) >= f->N))    {        padic_poly_zero(f);        return;    }    padic_poly_fit_length(f, lenF);    _padic_poly_sub(f->coeffs, &(f->val), f->N,                     g->coeffs, g->val, lenG, g->N,                     h->coeffs, h->val, lenH, h->N, ctx);    _padic_poly_set_length(f, lenF);    _padic_poly_normalise(f);}

voidacb_log1p(acb_t r, const acb_t z, slong prec){    slong magz, magx, magy;    if (acb_is_zero(z))    {        acb_zero(r);        return;    }    magx = arf_abs_bound_lt_2exp_si(arb_midref(acb_realref(z)));    magy = arf_abs_bound_lt_2exp_si(arb_midref(acb_imagref(z)));    magz = FLINT_MAX(magx, magy);    if (magz < -prec)    {        acb_log1p_tiny(r, z, prec);    }    else    {        if (magz < 0)            acb_add_ui(r, z, 1, prec + (-magz) + 4);        else            acb_add_ui(r, z, 1, prec + 4);        acb_log(r, r, prec);    }}

voidbernoulli_cache_compute(long n){    if (bernoulli_cache_num < n)    {        long i, new_num;        bernoulli_rev_t iter;        if (bernoulli_cache_num == 0)        {            flint_register_cleanup_function(bernoulli_cleanup);        }        new_num = FLINT_MAX(bernoulli_cache_num + 128, n);        bernoulli_cache = flint_realloc(bernoulli_cache, new_num * sizeof(fmpq));        for (i = bernoulli_cache_num; i < new_num; i++)            fmpq_init(bernoulli_cache + i);        i = new_num - 1;        i -= (i % 2);        bernoulli_rev_init(iter, i);        for ( ; i >= bernoulli_cache_num; i -= 2)        {            bernoulli_rev_next(fmpq_numref(bernoulli_cache + i),                fmpq_denref(bernoulli_cache + i), iter);        }        bernoulli_rev_clear(iter);        if (new_num > 1)            fmpq_set_si(bernoulli_cache + 1, -1, 2);        bernoulli_cache_num = new_num;    }}

int renf_elem_relative_condition_number_2exp(slong * cond, renf_elem_t a, renf_t nf){    fmpz * p;    slong len;    if (nf_elem_is_rational(a->elem, nf->nf))    {        *cond = 0;        return 1;    }    if (nf->nf->flag & NF_QUADRATIC)    {        p = QNF_ELEM_NUMREF(a->elem);        len = 2;    }    else    {        p = NF_ELEM(a->elem)->coeffs;        len = NF_ELEM(a->elem)->length;    }    return _fmpz_poly_relative_condition_number_2exp(cond, p,                len, nf->emb, FLINT_MAX(nf->prec, 16));}

void fmpq_poly_get_slice(fmpq_poly_t rop, const fmpq_poly_t op, long i, long j){    i = FLINT_MAX(i, 0);    j = FLINT_MIN(j, op->length);    if (i < j)    {        long k;        if (rop == op)        {            for (k = 0; k < i; k++)                fmpz_zero(rop->coeffs + k);            for (k = j; k < rop->length; k++)                fmpz_zero(rop->coeffs + k);            fmpq_poly_canonicalise(rop);        }        else        {            fmpq_poly_fit_length(rop, j);            _fmpq_poly_set_length(rop, j);            _fmpz_vec_set(rop->coeffs + i, op->coeffs + i, j - i);            fmpz_set(rop->den, op->den);            fmpq_poly_canonicalise(rop);        }    }    else    {        fmpq_poly_zero(rop);    }}

slongfmpz_mat_max_bits(const fmpz_mat_t mat){    slong i;    slong bits, row_bits, sign;    sign = 1;    bits = 0;    if (mat->r == 0 || mat->c == 0)        return 0;    for (i = 0; i < mat->r; i++)    {        row_bits = _fmpz_vec_max_bits(mat->rows[i], mat->c);        if (row_bits < 0)        {            row_bits = -row_bits;            sign = -1;        }        bits = FLINT_MAX(bits, row_bits);    }    return bits * sign;}

int_arf_add_eps(arf_t s, const arf_t x, int sgn, long prec, arf_rnd_t rnd){    arf_t t;    long bits;    bits = arf_bits(x);    if (bits == 0)    {        printf("_arf_add_eps/n");        abort();    }    bits = FLINT_MAX(bits, prec) + 10;    arf_init(t);    arf_set_si(t, sgn);    arf_mul_2exp_fmpz(t, t, ARF_EXPREF(x));    arf_mul_2exp_si(t, t, -bits);    arf_add(s, x, t, prec, rnd);    arf_clear(t);    return 1;}

voidarb_log_arf_huge(arb_t z, const arf_t x, slong prec){    arf_t t;    arb_t c;    fmpz_t exp;    slong wp;    arf_init(t);    arb_init(c);    fmpz_init(exp);    fmpz_neg(exp, ARF_EXPREF(x));    arf_mul_2exp_fmpz(t, x, exp);    wp = prec + 4 - fmpz_bits(exp);    wp = FLINT_MAX(wp, 4);    arb_log_arf(z, t, wp);    arb_const_log2(c, prec + 4);    arb_submul_fmpz(z, c, exp, prec);    arf_clear(t);    arb_clear(c);    fmpz_clear(exp);}

static void _padic_log_bsplit(fmpz_t z, const fmpz_t y, long v, const fmpz_t p, long N){    fmpz_t P, B, T;    long n;    if (fmpz_fits_si(p))        n = _padic_log_bound(v, N, fmpz_get_si(p));    else        n = (N - 1) / v;    n = FLINT_MAX(n, 2);    fmpz_init(P);    fmpz_init(B);    fmpz_init(T);    _padic_log_bsplit_series(P, B, T, y, 1, n);    n = fmpz_remove(B, B, p);    fmpz_pow_ui(P, p, n);    fmpz_divexact(T, T, P);    _padic_inv(B, B, p, N);    fmpz_mul(z, T, B);    fmpz_clear(P);    fmpz_clear(B);    fmpz_clear(T);}

void padic_ctx_init(padic_ctx_t ctx, const fmpz_t p, long N,                    enum padic_print_mode mode){    fmpz_init(ctx->p);    fmpz_set(ctx->p, p);    ctx->N = N;    ctx->pinv = (!COEFF_IS_MPZ(*p)) ? n_precompute_inverse(fmpz_get_ui(p)) : 0;    if (N > 0)    {        long i, len;        ctx->min = FLINT_MAX(1, N - 10);        ctx->max = N + 10;        len      = ctx->max - ctx->min;        ctx->pow = _fmpz_vec_init(len);        fmpz_pow_ui(ctx->pow, p, ctx->min);        for (i = 1; i < len; i++)            fmpz_mul(ctx->pow + i, ctx->pow + (i - 1), p);    }    else    {        ctx->min = 0;        ctx->max = 0;        ctx->pow = NULL;    }    ctx->mode = mode;}

void F_mpz_mod_poly_sub(F_mpz_mod_poly_t res, const F_mpz_mod_poly_t poly1, const F_mpz_mod_poly_t poly2){   ulong longer = FLINT_MAX(poly1->length, poly2->length);	F_mpz_mod_poly_fit_length(res, longer);		_F_mpz_mod_poly_sub(res, poly1, poly2);}

voidacb_hypgeom_erf(acb_t res, const acb_t z, slong prec){    double x, y, absz2, logz;    slong prec2;    if (!acb_is_finite(z))    {        acb_indeterminate(res);        return;    }    if (acb_is_zero(z))    {        acb_zero(res);        return;    }    if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), 0) < 0 &&            arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 0) < 0))    {        acb_hypgeom_erf_1f1a(res, z, prec);        return;    }    if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), 64) > 0 ||            arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 64) > 0))    {        acb_hypgeom_erf_asymp(res, z, prec, prec);        return;    }    x = arf_get_d(arb_midref(acb_realref(z)), ARF_RND_DOWN);    y = arf_get_d(arb_midref(acb_imagref(z)), ARF_RND_DOWN);    absz2 = x * x + y * y;    logz = 0.5 * log(absz2);    if (logz - absz2 < -(prec + 8) * 0.69314718055994530942)    {        /* If the asymptotic term is small, we can           compute with reduced precision */        prec2 = FLINT_MIN(prec + 4 + (y*y - x*x - logz) * 1.4426950408889634074, (double) prec);        prec2 = FLINT_MAX(8, prec2);        prec2 = FLINT_MIN(prec2, prec);        acb_hypgeom_erf_asymp(res, z, prec, prec2);    }    else if (arf_cmpabs(arb_midref(acb_imagref(z)), arb_midref(acb_realref(z))) > 0)    {        acb_hypgeom_erf_1f1a(res, z, prec);    }    else    {        acb_hypgeom_erf_1f1b(res, z, prec);    }}

slong_acb_get_mid_mag(const acb_t z){    slong rm, im;    rm = arf_abs_bound_lt_2exp_si(arb_midref(acb_realref(z)));    im = arf_abs_bound_lt_2exp_si(arb_midref(acb_imagref(z)));    return FLINT_MAX(rm, im);}

voidelem_poly_sub(elem_poly_struct * res,    const elem_poly_struct * op1, const elem_poly_struct * op2, const ring_t ring){    long max = FLINT_MAX(op1->length, op2->length);    elem_poly_fit_length(res, max, ring);    _elem_poly_sub(res->coeffs, op1->coeffs, op1->length, op2->coeffs, op2->length, ring->parent);    elem_poly_set_length(res, max, ring);    elem_poly_normalise(res, ring);}

voidfmpr_printd(const fmpr_t x, long digits){    mpfr_t t;    mpfr_init2(t, digits * 3.33 + 10);    mpfr_set_emin(MPFR_EMIN_MIN);    mpfr_set_emax(MPFR_EMAX_MAX);    fmpr_get_mpfr(t, x, MPFR_RNDN);    mpfr_printf("%.*Rg", FLINT_MAX(digits, 1), t);    mpfr_clear(t);}

void renf_randtest(renf_t nf, flint_rand_t state, slong len, slong prec, mp_bitcnt_t bits){    fmpz_poly_t p;    fmpq_poly_t p2;    fmpz * c_array;    slong * k_array;    slong n_interval, n_exact;    ulong i;    arb_t emb;    /* compute a random irreducible polynomial */    if (len <= 1)    {        fprintf(stderr, "ERROR (renf_randtest): got length < 2/n");        abort();    }    fmpz_poly_init(p);    do{        fmpz_poly_randtest_irreducible(p, state, len, bits);    }while(!fmpz_poly_has_real_root(p));    /* pick a random real root */    c_array = _fmpz_vec_init(p->length);    k_array = malloc((p->length) * sizeof(slong));    n_interval = 0;    fmpz_poly_isolate_real_roots(NULL, &n_exact,            c_array, k_array, &n_interval, p);    if (n_interval == 0)    {        fprintf(stderr, "Runtime error/n");        abort();    }    i = n_randint(state, n_interval);    /* construct the associated number field */    arb_init(emb);    arb_from_interval(emb, c_array+i, k_array[i], fmpz_bits(c_array + i) + FLINT_MAX(k_array[i], 0) + 2);    fmpq_poly_init(p2);    fmpq_poly_set_fmpz_poly(p2, p);    /* NOTE: renf init might not be happy with the ball emb */    renf_init(nf, p2, emb, prec);    _fmpz_vec_clear(c_array, p->length);    free(k_array);    fmpz_poly_clear(p);    fmpq_poly_clear(p2);    arb_clear(emb);}

intacb_hypgeom_2f1_choose(const acb_t z){    double x, y;    double mag[7];    int i, pick;    x = arf_get_d(arb_midref(acb_realref(z)), ARF_RND_DOWN);    y = arf_get_d(arb_midref(acb_imagref(z)), ARF_RND_DOWN);    x = FLINT_MAX(FLINT_MIN(x, 1e10), -1e10);    y = FLINT_MAX(FLINT_MIN(y, 1e10), -1e10);    mag[0] = x*x + y*y;  /* |z|^2 */    mag[4] = (1.0-x)*(1.0-x) + y*y;              /* |1-z|^2 */    if (mag[0] <= ALWAYS1)   return 0;    mag[1] = mag[0] / FLINT_MAX(mag[4], 1e-10);  /* |z/(z-1)|^2 */    if (mag[1] <= ALWAYS1)   return 1;    if (mag[0] <= ALWAYS2 || mag[1] <= ALWAYS2)        return mag[0] <= mag[1] ? 0 : 1;    mag[2] = 1.0 / mag[0];                    /* |1/z|^2 */    mag[3] = 1.0 / FLINT_MAX(mag[4], 1e-10);  /* 1/|1-z|^2 */    mag[5] = mag[4] / mag[0];                 /* |1-1/z|^2 = |(1-z)/z|^2 */    pick = 0;    for (i = 1; i < 6; i++)    {        if (mag[i] < mag[pick])            pick = i;    }    if (mag[pick] <= LIMIT)        return pick;    return 6;}

voidarb_sin_cos_pi(arb_t s, arb_t c, const arb_t x, long prec){    arb_t t;    arb_t u;    fmpz_t v;    if (arf_cmpabs_2exp_si(arb_midref(x), FLINT_MAX(65536, (4*prec))) > 0)    {        arf_zero(arb_midref(s));        mag_one(arb_radref(s));        arf_zero(arb_midref(c));        mag_one(arb_radref(c));        return;    }    arb_init(t);    arb_init(u);    fmpz_init(v);    arb_mul_2exp_si(t, x, 1);    arf_get_fmpz(v, arb_midref(t), ARF_RND_NEAR);    arb_sub_fmpz(t, t, v, prec);    arb_const_pi(u, prec);    arb_mul(t, t, u, prec);    arb_mul_2exp_si(t, t, -1);    switch (fmpz_fdiv_ui(v, 4))    {        case 0:            arb_sin_cos(s, c, t, prec);            break;        case 1:            arb_sin_cos(c, s, t, prec);            arb_neg(c, c);            break;        case 2:            arb_sin_cos(s, c, t, prec);            arb_neg(s, s);            arb_neg(c, c);            break;        default:            arb_sin_cos(c, s, t, prec);            arb_neg(s, s);            break;    }    fmpz_clear(v);    arb_clear(t);    arb_clear(u);}

void fmpz_mod_poly_sub(fmpz_mod_poly_t res,                        const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2){    long max = FLINT_MAX(poly1->length, poly2->length);    fmpz_mod_poly_fit_length(res, max);    _fmpz_mod_poly_sub(res->coeffs, poly1->coeffs, poly1->length,                                     poly2->coeffs, poly2->length, &(res->p));    _fmpz_mod_poly_set_length(res, max);    _fmpz_mod_poly_normalise(res);}

void _fmpz_mod_poly_sub(fmpz *res, const fmpz *poly1, long len1,                                    const fmpz *poly2, long len2, const fmpz_t p){    long i, len = FLINT_MAX(len1, len2);    _fmpz_poly_sub(res, poly1, len1, poly2, len2);    for (i = 0; i < len; i++)    {        if (fmpz_sgn(res + i) < 0)            fmpz_add(res + i, res + i, p);    }}

/* computes x + y * 2^shift (optionally negated) */slong_fmpr_add_mpn(fmpr_t z,        mp_srcptr xman, mp_size_t xn, int xsign, const fmpz_t xexp,        mp_srcptr yman, mp_size_t yn, int ysign, const fmpz_t yexp,        slong shift, slong prec, fmpr_rnd_t rnd){    slong tn, zn, alloc, ret, shift_bits, shift_limbs;    int negative;    mp_limb_t tmp_stack[ADD_STACK_ALLOC];    mp_limb_t cy;    mp_ptr tmp, tmp2;    shift_limbs = shift / FLINT_BITS;    shift_bits = shift % FLINT_BITS;    /* x does not overlap with y or the result -- outcome is       equivalent to adding/subtracting a small number to/from y       and rounding */    if (shift > xn * FLINT_BITS &&        prec != FMPR_PREC_EXACT &&        xn * FLINT_BITS + prec - (FLINT_BITS * (yn - 1)) < shift)    {        zn = (prec + FLINT_BITS - 1) / FLINT_BITS;        zn = FLINT_MAX(zn, yn) + 2;        shift_limbs = zn - yn;        alloc = zn;        ADD_TMP_ALLOC        flint_mpn_zero(tmp, shift_limbs);        flint_mpn_copyi(tmp + shift_limbs, yman, yn);        if (xsign == ysign)        {            tmp[0] = 1;        }        else        {            mpn_sub_1(tmp, tmp, zn, 1);            while (tmp[zn-1] == 0)                zn--;        }        ret = _fmpr_set_round_mpn(&shift, fmpr_manref(z), tmp, zn, ysign, prec, rnd);        shift -= shift_limbs * FLINT_BITS;        fmpz_add_si_inline(fmpr_expref(z), yexp, shift);        ADD_TMP_FREE        return ret;    }

void _fmpz_ramanujan_tau(fmpz_t res, fmpz_factor_t factors){    fmpz_poly_t poly;    fmpz_t tau_p, p_11, next, this, prev;    long k, r;    ulong max_prime;    max_prime = 1UL;    for (k = 0; k < factors->length; k++)    {        /* TODO: handle overflow properly */        max_prime = FLINT_MAX(max_prime, fmpz_get_ui(factors->p + k));    }    fmpz_poly_init(poly);    fmpz_poly_ramanujan_tau(poly, max_prime + 1);    fmpz_set_ui(res, 1);    fmpz_init(tau_p);    fmpz_init(p_11);    fmpz_init(next);    fmpz_init(this);    fmpz_init(prev);    for (k = 0; k < factors->length; k++)    {        ulong p = fmpz_get_ui(factors->p + k);        fmpz_set(tau_p, poly->coeffs + p);        fmpz_set_ui(p_11, p);        fmpz_pow_ui(p_11, p_11, 11);        fmpz_set_ui(prev, 1);        fmpz_set(this, tau_p);        for (r = 1; r < fmpz_get_ui(factors->exp + k); r++)        {            fmpz_mul(next, tau_p, this);            fmpz_submul(next, p_11, prev);            fmpz_set(prev, this);            fmpz_set(this, next);        }        fmpz_mul(res, res, this);    }    fmpz_clear(tau_p);    fmpz_clear(p_11);    fmpz_clear(next);    fmpz_clear(this);    fmpz_clear(prev);    fmpz_poly_clear(poly);}

voidacb_poly_add(acb_poly_t res, const acb_poly_t poly1,              const acb_poly_t poly2, long prec){    long max = FLINT_MAX(poly1->length, poly2->length);    acb_poly_fit_length(res, max);    _acb_poly_add(res->coeffs, poly1->coeffs, poly1->length, poly2->coeffs,                   poly2->length, prec);    _acb_poly_set_length(res, max);    _acb_poly_normalise(res);}

voidfq_sub(fq_t rop, const fq_t op1, const fq_t op2, const fq_ctx_t ctx){    slong max = FLINT_MAX(op1->length, op2->length);    fmpz_poly_fit_length(rop, max);    _fmpz_mod_poly_sub(rop->coeffs,                       op1->coeffs, op1->length, op2->coeffs, op2->length,                       fq_ctx_prime(ctx));    _fmpz_poly_set_length(rop, max);    _fmpz_poly_normalise(rop);}

void _harmonic_number(fmpz_t num, fmpz_t den, long n){    n = FLINT_MAX(n, 0);    if (n <= FLINT_HARMONIC_MAX_TINY)    {        fmpz_set_ui(num, FLINT_HARMONIC_TINY_P[n]);        fmpz_set_ui(den, FLINT_HARMONIC_TINY_Q[n]);    }    else    {        _mpq_harmonic_odd_balanced(num, den, n);    }}

voidfmpz_poly_sub(fmpz_poly_t res, const fmpz_poly_t poly1,              const fmpz_poly_t poly2){    slong max = FLINT_MAX(poly1->length, poly2->length);    fmpz_poly_fit_length(res, max);    _fmpz_poly_sub(res->coeffs, poly1->coeffs, poly1->length, poly2->coeffs,                   poly2->length);    _fmpz_poly_set_length(res, max);    _fmpz_poly_normalise(res);  /* there may have been cancellation */}