arb/acb_poly/rgamma_series.c

/*=============================================================================

    This file is part of ARB.

    ARB is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    ARB 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with ARB; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

=============================================================================*/
/******************************************************************************

    Copyright (C) 2013 Fredrik Johansson

******************************************************************************/

#include "acb_poly.h"

void acb_gamma_stirling_choose_param(int * reflect, long * r, long * n,
    const acb_t x, int use_reflect, int digamma, long prec);

void
_acb_poly_gamma_stirling_eval(acb_ptr res, const acb_t z, long n, long num, long prec);

void
_acb_poly_rgamma_series(acb_ptr res, acb_srcptr h, long hlen, long len, long prec)
{
    int reflect;
    long i, rflen, r, n, wp;
    acb_ptr t, u, v;
    acb_struct f[2];

    hlen = FLINT_MIN(hlen, len);
    wp = prec + FLINT_BIT_COUNT(prec);

    t = _acb_vec_init(len);
    u = _acb_vec_init(len);
    v = _acb_vec_init(len);
    acb_init(f);
    acb_init(f + 1);

    /* TODO: use real code at real numbers */
    if (0)
    {
    }
    else
    {
        /* otherwise use Stirling series */
        acb_gamma_stirling_choose_param(&reflect, &r, &n, h, 1, 0, wp);

        /* rgamma(h) = (gamma(1-h+r) sin(pi h)) / (rf(1-h, r) * pi), h = h0 + t*/
        if (reflect)
        {
            /* u = gamma(r+1-h) */
            acb_sub_ui(f, h, r + 1, wp);
            acb_neg(f, f);
            _acb_poly_gamma_stirling_eval(t, f, n, len, wp);
            _acb_poly_exp_series(u, t, len, len, wp);
            for (i = 1; i < len; i += 2)
                acb_neg(u + i, u + i);

            /* v = sin(pi x) */
            acb_const_pi(f + 1, wp);
            acb_mul(f, h, f + 1, wp);
            _acb_poly_sin_series(v, f, 2, len, wp);

            _acb_poly_mullow(t, u, len, v, len, len, wp);

            /* rf(1-h,r) * pi */
            if (r == 0)
            {
                acb_const_pi(u, wp);
                _acb_vec_scalar_div(v, t, len, u, wp);
            }
            else
            {
                acb_sub_ui(f, h, 1, wp);
                acb_neg(f, f);
                acb_set_si(f + 1, -1);
                rflen = FLINT_MIN(len, r + 1);
                _acb_poly_rising_ui_series(v, f, FLINT_MIN(2, len), r, rflen, wp);
                acb_const_pi(u, wp);
                _acb_vec_scalar_mul(v, v, rflen, u, wp);

                /* divide by rising factorial */
                /* TODO: might better to use div_series, when it has a good basecase */
                _acb_poly_inv_series(u, v, rflen, len, wp);
                _acb_poly_mullow(v, t, len, u, len, len, wp);
            }
        }
        else
        {
            /* rgamma(h) = rgamma(h+r) rf(h,r) */
            if (r == 0)
            {
                acb_add_ui(f, h, r, wp);
                _acb_poly_gamma_stirling_eval(t, f, n, len, wp);
                _acb_vec_neg(t, t, len);
                _acb_poly_exp_series(v, t, len, len, wp);
            }
            else
            {
                acb_set(f, h);
                acb_one(f + 1);
                rflen = FLINT_MIN(len, r + 1);
                _acb_poly_rising_ui_series(t, f, FLINT_MIN(2, len), r, rflen, wp);

                acb_add_ui(f, h, r, wp);
                _acb_poly_gamma_stirling_eval(v, f, n, len, wp);
                _acb_vec_neg(v, v, len);
                _acb_poly_exp_series(u, v, len, len, wp);

                _acb_poly_mullow(v, u, len, t, rflen, len, wp);
            }
        }
    }

    /* compose with nonconstant part */
    acb_zero(t);
    _acb_vec_set(t + 1, h + 1, hlen - 1);
    _acb_poly_compose_series(res, v, len, t, hlen, len, prec);

    acb_clear(f);
    acb_clear(f + 1);
    _acb_vec_clear(t, len);
    _acb_vec_clear(u, len);
    _acb_vec_clear(v, len);
}

void
acb_poly_rgamma_series(acb_poly_t res, const acb_poly_t f, long n, long prec)
{
    if (f->length == 0 || n == 0)
    {
        acb_poly_zero(res);
    }
    else
    {
        acb_poly_fit_length(res, n);
        _acb_poly_rgamma_series(res->coeffs, f->coeffs, f->length, n, prec);
        _acb_poly_set_length(res, n);
        _acb_poly_normalise(res);
    }
}