Пример #1
0
int main()
{
    slong iter;
    flint_rand_t state;

    flint_printf("set_interval_mpfr....");
    fflush(stdout);
    flint_randinit(state);

    for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
    {
        arb_t x;
        arf_t a, b;
        mpfr_t aa, bb;

        arb_init(x);
        arf_init(a);
        arf_init(b);
        mpfr_init2(aa, 200);
        mpfr_init2(bb, 200);

        arf_randtest_special(a, state, 200, 10);
        arf_randtest_special(b, state, 200, 10);
        if (arf_cmp(a, b) > 0)
            arf_swap(a, b);

        arf_get_mpfr(aa, a, MPFR_RNDD);
        arf_get_mpfr(bb, b, MPFR_RNDU);

        arb_set_interval_mpfr(x, aa, bb, 2 + n_randint(state, 200));

        if (!arb_contains_arf(x, a) || !arb_contains_arf(x, b))
        {
            flint_printf("FAIL:\n\n");
            flint_printf("x = "); arb_print(x); flint_printf("\n\n");
            flint_printf("a = "); arf_print(a); flint_printf("\n\n");
            flint_printf("b = "); arf_print(b); flint_printf("\n\n");
            flint_abort();
        }

        arb_clear(x);
        arf_clear(a);
        arf_clear(b);
        mpfr_clear(aa);
        mpfr_clear(bb);
    }

    flint_randclear(state);
    flint_cleanup();
    flint_printf("PASS\n");
    return EXIT_SUCCESS;
}
Пример #2
0
static __inline__ void
zeta_bsplit_init(zeta_bsplit_t S)
{
    arb_init(S->A);
    arb_init(S->B);
    arb_init(S->C);
    arb_init(S->D);
    arb_init(S->Q1);
    arb_init(S->Q2);
    arb_init(S->Q3);
}
Пример #3
0
static void
bound_rfac(arb_ptr F, const acb_t s, ulong n, slong len, slong wp)
{
    if (len == 1)
    {
        acb_rising_ui_get_mag(arb_radref(F), s, n);
        arf_set_mag(arb_midref(F), arb_radref(F));
        mag_zero(arb_radref(F + 0));
    }
    else
    {
        arb_struct sx[2];
        arb_init(sx + 0);
        arb_init(sx + 1);
        acb_abs(sx + 0, s, wp);
        arb_one(sx + 1);
        _arb_vec_zero(F, len);
        _arb_poly_rising_ui_series(F, sx, 2, n, len, wp);
        arb_clear(sx + 0);
        arb_clear(sx + 1);
    }
}
Пример #4
0
int main()
{
    slong iter;
    flint_rand_t state;

    flint_printf("const_e....");
    fflush(stdout);
    flint_randinit(state);

    for (iter = 0; iter < 250 * arb_test_multiplier(); iter++)
    {
        arb_t r;
        mpfr_t s;
        slong accuracy, prec;

        prec = 2 + n_randint(state, 1 << n_randint(state, 16));

        arb_init(r);
        mpfr_init2(s, prec + 1000);

        arb_const_e(r, prec);
        mpfr_set_ui(s, 1, MPFR_RNDN);
        mpfr_exp(s, s, MPFR_RNDN);

        if (!arb_contains_mpfr(r, s))
        {
            flint_printf("FAIL: containment\n\n");
            flint_printf("prec = %wd\n", prec);
            flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
            flint_abort();
        }

        accuracy = arb_rel_accuracy_bits(r);

        if (accuracy < prec - 4)
        {
            flint_printf("FAIL: poor accuracy\n\n");
            flint_printf("prec = %wd\n", prec);
            flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
            flint_abort();
        }

        arb_clear(r);
        mpfr_clear(s);
    }

    flint_randclear(state);
    flint_cleanup();
    flint_printf("PASS\n");
    return EXIT_SUCCESS;
}
Пример #5
0
void
_arb_poly_evaluate_horner(arb_t y, arb_srcptr f, slong len,
                           const arb_t x, slong prec)
{
    if (len == 0)
    {
        arb_zero(y);
    }
    else if (len == 1 || arb_is_zero(x))
    {
        arb_set_round(y, f, prec);
    }
    else if (len == 2)
    {
        arb_mul(y, x, f + 1, prec);
        arb_add(y, y, f + 0, prec);
    }
    else
    {
        slong i = len - 1;
        arb_t t, u;

        arb_init(t);
        arb_init(u);
        arb_set(u, f + i);

        for (i = len - 2; i >= 0; i--)
        {
            arb_mul(t, u, x, prec);
            arb_add(u, f + i, t, prec);
        }

        arb_swap(y, u);

        arb_clear(t);
        arb_clear(u);
    }
}
Пример #6
0
renf_elem_class::operator double() const noexcept
{
    if (nf == nullptr)
    {
        arb_t s;
        arb_init(s);
        arb_set_fmpq(s, b, 128);
        double ans = arf_get_d(arb_midref(s), ARF_RND_NEAR);
        arb_clear(s);
        return ans;
    }
    else
        return renf_elem_get_d(a, nf->renf_t(), ARF_RND_NEAR);
}
Пример #7
0
int main()
{
    int iter;
    FLINT_TEST_INIT(state);

    test_field1(state);
    test_field2(state);

    for (iter = 0; iter < 100; iter++)
    {
        renf_t nf;
        renf_elem_t a;
        fmpz_t f;
        arb_t e;

        fmpz_init(f);
        arb_init(e);
        renf_randtest(nf, state,
                          2 + n_randint(state, 20),   /* length */
                          8 + n_randint(state, 2408), /* prec   */
                          10 + n_randint(state, 10)   /* bits   */
                          );
        renf_elem_init(a, nf);
        renf_elem_randtest(a, state, 30 + n_randint(state, 10), nf);

        renf_elem_ceil(f, a, nf);

        arb_sub_fmpz(e, a->emb, f, 1024);
        if (arb_is_positive(e))
        {
            printf("FAIL:\n");
            abort();
        }
        arb_add_ui(e, e, 1, 1024);
        if (arb_is_negative(e))
        {
            printf("FAIL:\n");
            abort();
        }

        renf_elem_clear(a, nf);
        renf_clear(nf);
        fmpz_clear(f);
        arb_clear(e);
    }

    FLINT_TEST_CLEANUP(state);

    return 0;
}
Пример #8
0
/* TODO: BSGS can reduce to nv mul */
void
acb_dirichlet_arb_quadratic_powers(arb_ptr v, slong nv, const arb_t x, slong prec)
{
    slong i;
    arb_t dx, x2;
    arb_init(dx);
    arb_init(x2);
    arb_set(dx, x);
    arb_mul(x2, x, x, prec);
    for (i = 0; i < nv; i++)
    {
        if (i == 0)
            arb_one(v + i);
        else if (i == 1)
            arb_set_round(v + i, x, prec);
        else
        {
            arb_mul(dx, dx, x2, prec);
            arb_mul(v + i, v + i - 1, dx, prec);
        }
    }
    arb_clear(dx);
    arb_clear(x2);
}
Пример #9
0
std::string renf_elem_class::to_string(int flags) const noexcept
{
    std::string s;

    assert(!((flags & EANTIC_STR_D) && (flags & EANTIC_STR_ARB)));

    // call to renf_elem_get_str_pretty
    if (nf == nullptr)
    {
        if (flags & EANTIC_STR_ALG)
        {
            char * u = fmpq_get_str(nullptr, 10, b);
            s += u;
            flint_free(u);

            if (flags & (EANTIC_STR_D | EANTIC_STR_ARB)) s += " ~ ";
        }
        if (flags & EANTIC_STR_D)
        {
            char * u = (char *) flint_malloc(20 * sizeof(char));
            sprintf(u, "%lf", fmpq_get_d(b));
            s += u;
            flint_free(u);
        }
        if (flags & EANTIC_STR_ARB)
        {
            char * u;
            arb_t x;
            arb_init(x);
            arb_set_fmpq(x, b, 128);
            u = arb_get_str(x, 64, 0);
            s += u;
            arb_clear(x);
            flint_free(u);
        }
    }
    else
    {
        char * u = renf_elem_get_str_pretty(renf_elem_t(), parent().gen_name().c_str(), parent().renf_t(), 10, flags);
        s += u;
        flint_free(u);
    }

    if (flags != EANTIC_STR_ALG && flags != EANTIC_STR_D && flags != EANTIC_STR_ARB)
        return "(" + s + ")";
    else
        return s;
}
Пример #10
0
void
_arb_poly_tan_series(arb_ptr g,
    arb_srcptr h, slong hlen, slong len, slong prec)
{
    hlen = FLINT_MIN(hlen, len);

    if (hlen == 1)
    {
        arb_tan(g, h, prec);
        _arb_vec_zero(g + 1, len - 1);
    }
    else if (len == 2)
    {
        arb_t t;
        arb_init(t);
        arb_tan(g, h, prec);
        arb_mul(t, g, g, prec);
        arb_add_ui(t, t, 1, prec);
        arb_mul(g + 1, t, h + 1, prec);  /* safe since hlen >= 2 */
        arb_clear(t);
    }
    else
    {
        arb_ptr t, u;

        t = _arb_vec_init(2 * len);
        u = t + len;

        NEWTON_INIT(TAN_NEWTON_CUTOFF, len)

        NEWTON_BASECASE(n)
        _arb_poly_sin_cos_series_basecase(t, u, h, hlen, n, prec, 0);
        _arb_poly_div_series(g, t, n, u, n, n, prec);
        NEWTON_END_BASECASE

        NEWTON_LOOP(m, n)
        _arb_poly_mullow(u, g, m, g, m, n, prec);
        arb_add_ui(u, u, 1, prec);
        _arb_poly_atan_series(t, g, m, n, prec);
        _arb_poly_sub(t + m, h + m, FLINT_MAX(0, hlen - m), t + m, n - m, prec);
        _arb_poly_mullow(g + m, u, n, t + m, n - m, n - m, prec);
        NEWTON_END_LOOP

        NEWTON_END

        _arb_vec_clear(t, 2 * len);
    }
}
Пример #11
0
void
nd_axis_init(nd_axis_t axis,
        const char *name, int total_count, column_reduction_t r,
        int component_axis_count, struct nd_component_axis *component_axes,
        slong prec)
{
    int i, idx;

    /* set compound axis hack data */
    axis->component_axis_count = component_axis_count;
    axis->component_axes = component_axes;

    /* set the name */
    axis->name = malloc(strlen(name) + 1);
    strcpy(axis->name, name);

    /* set the counts */
    axis->n = total_count;
    axis->k = r->selection_len;

    /* allocate some bookkeeping vectors  */
    axis->selection = calloc(axis->k, sizeof(int));
    axis->is_selected = calloc(axis->n, sizeof(int));
    axis->request_update = calloc(axis->n, sizeof(int));

    /* initialize the bookkeeping vectors */
    for (i = 0; i < axis->k; i++)
    {
        idx = r->selection[i];
        axis->selection[i] = idx;
        axis->is_selected[idx] = 1;
        axis->request_update[idx] = 1;
    }

    /* initialize the arbitrary precision weight arrays */
    if (r->agg_mode == AGG_NONE)
    {
        axis->agg_weights = NULL;
    }
    else
    {
        axis->agg_weights = _arb_vec_init(axis->n);
        arb_init(axis->agg_weight_divisor);
    }

    /* initialize weight values */
    nd_axis_update_precision(axis, r, prec);
}
Пример #12
0
/* The floor+vec method *requires* n <= 1498 for floor(p(n)/2^64)
   to be equal to floor(T/2^64). It is faster up to n ~= 1200.
   With doubles, it is faster up to n ~= 500. */
void
_partitions_fmpz_ui(fmpz_t res, ulong n, int use_doubles)
{
    if (n < NUMBER_OF_SMALL_PARTITIONS)
    {
        fmpz_set_ui(res, partitions_lookup[n]);
    }
    else if (FLINT_BITS == 64 && (n < 500 || (!use_doubles && n < 1200)))
    {
        mp_ptr tmp = flint_malloc((n + 1) * sizeof(mp_limb_t));

        if (n < 417)  /* p(n) < 2^64 */
        {
            partitions_vec(tmp, n + 1);
            fmpz_set_ui(res, tmp[n]);
        }
        else
        {
            arb_t x;
            arb_init(x);
            fmpz_set_ui(res, n);
            partitions_leading_fmpz(x, res, 4 * sqrt(n) - 50);
            arb_mul_2exp_si(x, x, -64);
            arb_floor(x, x, 4 * sqrt(n) - 50);

            if (arb_get_unique_fmpz(res, x))
            {
                fmpz_mul_2exp(res, res, 64);
                partitions_vec(tmp, n + 1);
                fmpz_add_ui(res, res, tmp[n]);
            }
            else
            {
                flint_printf("warning: failed at %wu\n", n);
                fmpz_set_ui(res, n);
                partitions_fmpz_fmpz_hrr(res, res, use_doubles);
            }
            arb_clear(x);
        }
        flint_free(tmp);
    }
    else
    {
        fmpz_set_ui(res, n);
        partitions_fmpz_fmpz_hrr(res, res, use_doubles);
    }
}
Пример #13
0
/* compose by poly2 = a*x^n + c, no aliasing; n >= 1 */
void
_arb_poly_compose_axnc(arb_ptr res, arb_srcptr poly1, slong len1,
    const arb_t c, const arb_t a, slong n, slong prec)
{
    slong i;

    _arb_vec_set_round(res, poly1, len1, prec);
    /* shift by c (c = 0 case will be fast) */
    _arb_poly_taylor_shift(res, c, len1, prec);

    /* multiply by powers of a */
    if (!arb_is_one(a))
    {
        if (arb_equal_si(a, -1))
        {
            for (i = 1; i < len1; i += 2)
                arb_neg(res + i, res + i);
        }
        else if (len1 == 2)
        {
            arb_mul(res + 1, res + 1, a, prec);
        }
        else
        {
            arb_t t;
            arb_init(t);
            arb_set(t, a);

            for (i = 1; i < len1; i++)
            {
                arb_mul(res + i, res + i, t, prec);
                if (i + 1 < len1)
                    arb_mul(t, t, a, prec);
            }

            arb_clear(t);
        }
    }

    /* stretch */
    for (i = len1 - 1; i >= 1 && n > 1; i--)
    {
        arb_swap(res + i * n, res + i);
        _arb_vec_zero(res + (i - 1) * n + 1, n - 1);
    }
}
Пример #14
0
static void
_acb_hypgeom_li_offset(acb_t res, const acb_t z, long prec)
{
    if (acb_is_int(z) && arf_cmp_2exp_si(arb_midref(acb_realref(z)), 1) == 0)
    {
        acb_zero(res);
    }
    else
    {
        arb_t t;
        arb_init(t);
        _acb_hypgeom_const_li2(t, prec);
        _acb_hypgeom_li(res, z, prec);
        arb_sub(acb_realref(res), acb_realref(res), t, prec);
        arb_clear(t);
    }
}
Пример #15
0
void test_field1(flint_rand_t state)
{
    /* tests in QQ[sqrt(5)] */
    int iter;

    fmpq_t k;
    fmpq_poly_t p;
    arb_t emb;
    renf_t nf;
    renf_elem_t a;

    fmpq_poly_init(p);
    fmpq_poly_set_coeff_si(p, 2, 1);
    fmpq_poly_set_coeff_si(p, 1, -1);
    fmpq_poly_set_coeff_si(p, 0, -1);

    arb_init(emb);
    arb_set_d(emb, 1.61803398874989);
    arb_add_error_2exp_si(emb, -20);
    renf_init(nf, p, emb, 20 + n_randint(state, 20));
    arb_clear(emb);

    renf_elem_init(a, nf);
    fmpq_init(k);

    /* (1+sqrt(5))/2 vs Fibonacci */
    fmpq_poly_zero(p);
    fmpq_poly_set_coeff_si(p, 1, -1);
    for (iter = 1; iter < 50; iter++)
    {
        fprintf(stderr, "start iter = %d\n", iter);
        fflush(stderr);
        fmpz_fib_ui(fmpq_numref(k), iter+1);
        fmpz_fib_ui(fmpq_denref(k), iter);
        fmpq_poly_set_coeff_fmpq(p, 0, k);
        renf_elem_set_fmpq_poly(a, p, nf);
        check_ceil(a, nf, 1 - iter % 2, "sqrt(5)");
        fprintf(stderr, "end\n");
        fflush(stderr);
    }

    renf_elem_clear(a, nf);
    renf_clear(nf);
    fmpq_clear(k);
    fmpq_poly_clear(p);
}
Пример #16
0
void
arb_bernoulli_fmpz(arb_t res, const fmpz_t n, slong prec)
{
    if (fmpz_cmp_ui(n, UWORD_MAX) <= 0)
    {
        if (fmpz_sgn(n) >= 0)
            arb_bernoulli_ui(res, fmpz_get_ui(n), prec);
        else
            arb_zero(res);
    }
    else if (fmpz_is_odd(n))
    {
        arb_zero(res);
    }
    else
    {
        arb_t t;
        slong wp;

        arb_init(t);
        wp = prec + 2 * fmpz_bits(n);

        /* zeta(n) ~= 1 */
        arf_one(arb_midref(res));
        mag_one(arb_radref(res));
        mag_mul_2exp_si(arb_radref(res), arb_radref(res), WORD_MIN);

        /* |B_n| = 2 * n! / (2*pi)^n * zeta(n) */
        arb_gamma_fmpz(t, n, wp);
        arb_mul_fmpz(t, t, n, wp);
        arb_mul(res, res, t, wp);

        arb_const_pi(t, wp);
        arb_mul_2exp_si(t, t, 1);
        arb_pow_fmpz(t, t, n, wp);

        arb_div(res, res, t, prec);
        arb_mul_2exp_si(res, res, 1);

        if (fmpz_fdiv_ui(n, 4) == 0)
            arb_neg(res, res);

        arb_clear(t);
    }
}
Пример #17
0
slong renf_set_embeddings_fmpz_poly(renf * nf, fmpz_poly_t pol, slong lim, slong prec)
{
    slong i, n, n_exact, n_interval;
    fmpq_poly_t p2;
    arb_t a;
    fmpz * c;
    slong * k;

    n = fmpz_poly_num_real_roots_upper_bound(pol);
    c = _fmpz_vec_init(n);
    k = (slong *) flint_malloc(n * sizeof(slong));

    fmpz_poly_isolate_real_roots(NULL, &n_exact, c, k, &n_interval, pol);

    if (n_exact)
    {
        fprintf(stderr, "ERROR (fmpz_poly_real_embeddings): rational roots\n");
        abort();
    }

    arb_init(a);
    fmpq_poly_init(p2);
    fmpz_one(fmpq_poly_denref(p2));
    fmpq_poly_fit_length(p2, pol->length);
    _fmpz_vec_set(p2->coeffs, pol->coeffs, pol->length);
    p2->length = pol->length;
    for (i = 0; i < FLINT_MIN(lim, n_interval); i++)
    {
        arb_set_fmpz(a, c + i);
        arb_mul_2exp_si(a, a, 1);
        arb_add_si(a, a, 1, prec);
        mag_one(arb_radref(a));
        arb_mul_2exp_si(a, a, k[i] - 1);

        renf_init(nf + i, p2, a, prec);

    }

    arb_clear(a);
    fmpq_poly_clear(p2);
    _fmpz_vec_clear(c, n);
    flint_free(k);

    return n_interval;
}
Пример #18
0
void
arb_fac2_ui(arb_t res, ulong n, long prec)
{
    if (n % 2 == 0)
    {
        arb_fac_ui(res, n / 2, prec);
        arb_mul_2exp_si(res, res, n / 2);
    }
    else
    {
        arb_t t;
        arb_init(t);
        arb_fac2_ui(t, n - 1, prec + 5);
        arb_fac_ui(res, n, prec + 5);
        arb_div(res, res, t, prec);
        arb_clear(t);
    }
}
Пример #19
0
Файл: pow.c Проект: akobel/arb
void
_arb_pow_exp(arb_t z, const arb_t x, int negx, const arb_t y, long prec)
{
    arb_t t;
    arb_init(t);

    if (negx)
    {
        arb_neg(t, x);
        arb_log(t, t, prec);
    }
    else
        arb_log(t, x, prec);

    arb_mul(t, t, y, prec);
    arb_exp(z, t, prec);
    arb_clear(t);
}
Пример #20
0
void check_init(fmpq_poly_t p, double demb, double rad1, double rad2, slong iter, flint_rand_t state)
{
    renf_t nf;
    arb_t emb;
    slong prec, i;

    arb_init(emb);
    for (i = 0; i < iter; i++)
    {
        prec = 8 + n_randint(state, 2048);
        randomized_embedding(emb, demb, rad1, rad2);

        renf_init(nf, p, emb, prec);
        check_renf(nf);
        renf_clear(nf);
    }
    arb_clear(emb);
}
Пример #21
0
int main()
{
    slong iter;
    flint_rand_t state;

    flint_printf("zeta_ui_asymp....");
    fflush(stdout);
    flint_randinit(state);

    for (iter = 0; iter < 10000; iter++)
    {
        arb_t r;
        ulong n;
        mpfr_t s;
        slong prec;

        prec = 2 + n_randint(state, 1 << n_randint(state, 10));

        arb_init(r);
        mpfr_init2(s, prec + 100);

        n = 2 + n_randint(state, 1 << n_randint(state, 10));

        arb_zeta_ui_asymp(r, n, prec);
        mpfr_zeta_ui(s, (unsigned long) FLINT_MIN(n, ULONG_MAX), MPFR_RNDN);

        if (!arb_contains_mpfr(r, s))
        {
            flint_printf("FAIL: containment\n\n");
            flint_printf("n = %wu\n\n", n);
            flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
            flint_printf("s = "); mpfr_printf("%.275Rf\n", s); flint_printf("\n\n");
            abort();
        }

        arb_clear(r);
        mpfr_clear(s);
    }

    flint_randclear(state);
    flint_cleanup();
    flint_printf("PASS\n");
    return EXIT_SUCCESS;
}
Пример #22
0
int
main(void)
{
    int i, result;
    flint_rand_t state;

    printf("get_coeff_ptr....");
    fflush(stdout);

    flint_randinit(state);

    for (i = 0; i < 1000; i++)
    {
        arb_poly_t A;
        arb_t a;
        long n = n_randint(state, 100);

        arb_poly_init(A);
        arb_poly_randtest(A, state, n_randint(state, 100), 100, 10);
        arb_init(a);

        arb_poly_get_coeff_arb(a, A, n);

        result = n < arb_poly_length(A) ?
                 arb_equal(a, arb_poly_get_coeff_ptr(A, n)) :
                 arb_poly_get_coeff_ptr(A, n) == NULL;
        if (!result)
        {
            printf("FAIL:\n");
            printf("A = "), arb_poly_printd(A, 10), printf("\n\n");
            printf("a = "), arb_print(a), printf("\n\n");
            printf("n = %ld\n\n", n);
            abort();
        }

        arb_poly_clear(A);
        arb_clear(a);
    }

    flint_randclear(state);
    flint_cleanup();
    printf("PASS\n");
    return 0;
}
Пример #23
0
int
f_aj(arb_t m, const arb_t t, params_t * p, slong prec)
{
    slong k;
    acb_t z, zu;
    arb_t abs;

    arb_init(abs);
    acb_init(z);
    acb_init(zu);

    arb_const_pi(abs, prec);
    arb_mul_2exp_si(abs, abs, -2); /* Pi/4 */

    arb_set(acb_realref(z), t);
    arb_set(acb_imagref(z), abs);

    acb_sinh(z, z, prec);
    arb_mul_2exp_si(abs, abs, 1); /* Pi/2 */
    acb_mul_arb(z, z, abs, prec);
    acb_tanh(z, z, prec);

    arb_one(m);
    for (k = 0; k < p->len; k++)
    {
        acb_sub(zu, z, p->z + k, prec);
        if (acb_contains_zero(zu))
        {
            arb_clear(abs);
            acb_clear(zu);
            acb_clear(z);
            return 0;
        }
        acb_abs(abs, zu, prec);
        arb_mul(m, m, abs, prec);
    }
    arb_inv(m, m, prec);

    arb_clear(abs);
    acb_clear(zu);
    acb_clear(z);
    return 1;
}
Пример #24
0
void
arb_poly_fit_length(arb_poly_t poly, slong len)
{
    slong i;

    if (len > poly->alloc)
    {
        if (len < 2 * poly->alloc)
            len = 2 * poly->alloc;

        poly->coeffs = flint_realloc(poly->coeffs,
            len * sizeof(arb_struct));

        for (i = poly->alloc; i < len; i++)
            arb_init(poly->coeffs + i);

        poly->alloc = len;
    }
}
Пример #25
0
/* rate matrix and edge rates have already been updated */
static void
_update_transition_matrices(cross_site_ws_t w, slong prec)
{
    slong i, j;
    arb_t s;
    arb_init(s);
    for (i = 0; i < w->rate_category_count; i++)
    {
        for (j = 0; j < w->edge_count; j++)
        {
            arb_mat_struct *tmat;
            tmat = cross_site_ws_transition_matrix(w, i, j);
            arb_mul(s, w->rate_mix_rates + i, w->edge_rates + j, prec);
            arb_mat_scalar_mul_arb(tmat, w->rate_matrix, s, prec);
            arb_mat_exp(tmat, tmat, prec);
        }
    }
    arb_clear(s);
}
Пример #26
0
/*
 * Update the frechet matrix for each rate category and edge.
 * At this point the rate matrix has been normalized
 * to have zero row sums, but it has not been scaled
 * by the edge rate coefficients.
 * The frechet matrices must already have been initialized.
 */
static void
_update_state_pair_frechet_matrices(
        cross_site_ws_t csw, model_and_data_t m,
        nd_axis_struct *edge_axis,
        slong first_state, slong second_state, slong prec)
{
    arb_mat_t P, L, Q;
    slong cat;
    arb_t rate;

    slong state_count = model_and_data_state_count(m);
    slong edge_count = model_and_data_edge_count(m);
    slong rate_category_count = model_and_data_rate_category_count(m);

    arb_init(rate);
    arb_mat_init(P, state_count, state_count);
    arb_mat_init(L, state_count, state_count);
    arb_mat_init(Q, state_count, state_count);
    arb_set(arb_mat_entry(L, first_state, second_state),
            arb_mat_entry(csw->rate_matrix, first_state, second_state));

    for (cat = 0; cat < rate_category_count; cat++)
    {
        slong edge;
        const arb_struct * cat_rate = csw->rate_mix_rates + cat;
        for (edge = 0; edge < edge_count; edge++)
        {
            slong idx = m->edge_map->order[edge];
            const arb_struct * edge_rate = csw->edge_rates + idx;
            arb_mat_struct *fmat;
            if (!edge_axis->request_update[edge]) continue;
            fmat = cross_site_ws_trans_frechet_matrix(csw, cat, idx);
            arb_mul(rate, edge_rate, cat_rate, prec);
            arb_mat_scalar_mul_arb(Q, csw->rate_matrix, rate, prec);
            _arb_mat_exp_frechet(P, fmat, Q, L, prec);
        }
    }

    arb_clear(rate);
    arb_mat_clear(P);
    arb_mat_clear(L);
    arb_mat_clear(Q);
}
Пример #27
0
void arb_twobytwo_diag(arb_t u1, arb_t u2, const arb_t a, const arb_t b, const arb_t d, slong prec) {
    // Compute the orthogonal matrix that diagonalizes
    //
    //    A = [a b]
    //        [b d]
    //
    // This matrix will have the form
    //
    //    U = [cos x , -sin x]
    //        [sin x, cos x]
    //
    // where the diagonal matrix is U^t A U.
    // We set u1 = cos x, u2 = -sin x.

    if(arb_contains_zero(b)) {
        // this is not quite right (doesn't set error intervals)
        arb_set_ui(u1, 1);
        arb_set_ui(u2, 0);
        return;
    }
    arb_t x; arb_init(x);

    arb_mul(u1, b, b, prec);            // u1 = b^2
    arb_sub(u2, a, d, prec);            // u2 = a - d
    arb_mul_2exp_si(u2, u2, -1);        // u2 = (a - d)/2
    arb_mul(u2, u2, u2, prec);          // u2 = ( (a - d)/2 )^2
    arb_add(u1, u1, u2, prec);          // u1 = b^2 + ( (a-d)/2 )^2
    arb_sqrt(u1, u1, prec);             // u1 = sqrt(above)

    arb_mul_2exp_si(u1, u1, 1);         // u1 = 2 (sqrt (above) )
    arb_add(u1, u1, d, prec);           // u1 += d
    arb_sub(u1, u1, a, prec);           // u1 -= a
    arb_mul_2exp_si(u1, u1, -1);        // u1 = (d - a)/2 + sqrt(b^2 + ( (a-d)/2 )^2)

    arb_mul(x, u1, u1, prec);
    arb_addmul(x, b, b, prec);          // x = u1^2 + b^2
    arb_sqrt(x, x, prec);               // x = sqrt(u1^2 + b^2)
    arb_div(u2, u1, x, prec);
    arb_div(u1, b, x, prec);
    arb_neg(u1, u1);

    arb_clear(x);
}
Пример #28
0
/* series of c^(d+x) */
static __inline__ void
_arb_poly_pow_cpx(arb_ptr res, const arb_t c, const arb_t d, long trunc, long prec)
{
    long i;
    arb_t logc;

    arb_init(logc);
    arb_log(logc, c, prec);
    arb_mul(res + 0, logc, d, prec);
    arb_exp(res + 0, res + 0, prec);

    for (i = 1; i < trunc; i++)
    {
        arb_mul(res + i, res + i - 1, logc, prec);
        arb_div_ui(res + i, res + i, i, prec);
    }

    arb_clear(logc);
}
Пример #29
0
/* invalid in (-1,0) */
int
_acb_hypgeom_legendre_q_single_valid(const acb_t z)
{
    arb_t t;
    int ok;

    if (!arb_contains_zero(acb_imagref(z)))
        return 1;

    if (arb_is_positive(acb_imagref(z)))
        return 1;

    arb_init(t);
    arb_one(t);
    arb_neg(t, t);
    ok = arb_lt(acb_realref(z), t);
    arb_clear(t);
    return ok;
}
Пример #30
0
void
_arb_poly_compose_series(arb_ptr res, arb_srcptr poly1, slong len1,
                            arb_srcptr poly2, slong len2, slong n, slong prec)
{
    if (len2 == 1)
    {
        arb_set_round(res, poly1, prec);
        _arb_vec_zero(res + 1, n - 1);
    }
    else if (_arb_vec_is_zero(poly2 + 1, len2 - 2))  /* poly2 is a monomial */
    {
        slong i, j;
        arb_t t;

        arb_init(t);
        arb_set(t, poly2 + len2 - 1);
        arb_set_round(res, poly1, prec);

        for (i = 1, j = len2 - 1; i < len1 && j < n; i++, j += len2 - 1)
        {
            arb_mul(res + j, poly1 + i, t, prec);

            if (i + 1 < len1 && j + len2 - 1 < n)
                arb_mul(t, t, poly2 + len2 - 1, prec);
        }

        if (len2 != 2)
            for (i = 1; i < n; i++)
                if (i % (len2 - 1) != 0)
                    arb_zero(res + i);

        arb_clear(t);
    }
    else if (len1 < 6 || n < 6)
    {
        _arb_poly_compose_series_horner(res, poly1, len1, poly2, len2, n, prec);
    }
    else
    {
        _arb_poly_compose_series_brent_kung(res, poly1, len1, poly2, len2, n, prec);
    }
}