Implementation of some special functions that have a representation as nested sums. More...

#include "inifcns.h"
#include "add.h"
#include "constant.h"
#include "lst.h"
#include "mul.h"
#include "numeric.h"
#include "operators.h"
#include "power.h"
#include "pseries.h"
#include "relational.h"
#include "symbol.h"
#include "utils.h"
#include "wildcard.h"
#include <cln/cln.h>
#include <sstream>
#include <stdexcept>
#include <vector>
#include <cmath>

Namespaces
namespace	GiNaC

Functions
static ex	GiNaC::G2_evalf (const ex &x_, const ex &y)

static ex	GiNaC::G2_eval (const ex &x_, const ex &y)

static ex	GiNaC::G3_evalf (const ex &x_, const ex &s_, const ex &y)

static ex	GiNaC::G3_eval (const ex &x_, const ex &s_, const ex &y)

static ex	GiNaC::Li_evalf (const ex &m_, const ex &x_)

static ex	GiNaC::Li_eval (const ex &m_, const ex &x_)

static ex	GiNaC::Li_series (const ex &m, const ex &x, const relational &rel, int order, unsigned options)

static ex	GiNaC::Li_deriv (const ex &m_, const ex &x_, unsigned deriv_param)

static void	GiNaC::Li_print_latex (const ex &m_, const ex &x_, const print_context &c)

	GiNaC::REGISTER_FUNCTION (Li, evalf_func(Li_evalf). eval_func(Li_eval). series_func(Li_series). derivative_func(Li_deriv). print_func< print_latex >(Li_print_latex). do_not_evalf_params())

static ex	GiNaC::S_evalf (const ex &n, const ex &p, const ex &x)

static ex	GiNaC::S_eval (const ex &n, const ex &p, const ex &x)

static ex	GiNaC::S_series (const ex &n, const ex &p, const ex &x, const relational &rel, int order, unsigned options)

static ex	GiNaC::S_deriv (const ex &n, const ex &p, const ex &x, unsigned deriv_param)

static void	GiNaC::S_print_latex (const ex &n, const ex &p, const ex &x, const print_context &c)

	GiNaC::REGISTER_FUNCTION (S, evalf_func(S_evalf). eval_func(S_eval). series_func(S_series). derivative_func(S_deriv). print_func< print_latex >(S_print_latex). do_not_evalf_params())

static ex	GiNaC::H_evalf (const ex &x1, const ex &x2)

static ex	GiNaC::H_eval (const ex &m_, const ex &x)

static ex	GiNaC::H_series (const ex &m, const ex &x, const relational &rel, int order, unsigned options)

static ex	GiNaC::H_deriv (const ex &m_, const ex &x, unsigned deriv_param)

static void	GiNaC::H_print_latex (const ex &m_, const ex &x, const print_context &c)

	GiNaC::REGISTER_FUNCTION (H, evalf_func(H_evalf). eval_func(H_eval). series_func(H_series). derivative_func(H_deriv). print_func< print_latex >(H_print_latex). do_not_evalf_params())

ex	GiNaC::convert_H_to_Li (const ex &parameterlst, const ex &arg)
	Converts a given list containing parameters for H in Remiddi/Vermaseren notation into the corresponding GiNaC functions. More...

static ex	GiNaC::zeta1_evalf (const ex &x)

static ex	GiNaC::zeta1_eval (const ex &m)

static ex	GiNaC::zeta1_deriv (const ex &m, unsigned deriv_param)

static void	GiNaC::zeta1_print_latex (const ex &m_, const print_context &c)

static ex	GiNaC::zeta2_evalf (const ex &x, const ex &s)

static ex	GiNaC::zeta2_eval (const ex &m, const ex &s_)

static ex	GiNaC::zeta2_deriv (const ex &m, const ex &s, unsigned deriv_param)

static void	GiNaC::zeta2_print_latex (const ex &m_, const ex &s_, const print_context &c)

Detailed Description

Implementation of some special functions that have a representation as nested sums.

The functions are: classical polylogarithm Li(n,x) multiple polylogarithm Li(lst{m_1,...,m_k},lst{x_1,...,x_k}) G(lst{a_1,...,a_k},y) or G(lst{a_1,...,a_k},lst{s_1,...,s_k},y) Nielsen's generalized polylogarithm S(n,p,x) harmonic polylogarithm H(m,x) or H(lst{m_1,...,m_k},x) multiple zeta value zeta(m) or zeta(lst{m_1,...,m_k}) alternating Euler sum zeta(m,s) or zeta(lst{m_1,...,m_k},lst{s_1,...,s_k})

Some remarks:

All formulae used can be looked up in the following publications: [Kol] Nielsen's Generalized Polylogarithms, K.S.Kolbig, SIAM J.Math.Anal. 17 (1986), pp. 1232-1258. [Cra] Fast Evaluation of Multiple Zeta Sums, R.E.Crandall, Math.Comp. 67 (1998), pp. 1163-1172. [ReV] Harmonic Polylogarithms, E.Remiddi, J.A.M.Vermaseren, Int.J.Mod.Phys. A15 (2000), pp. 725-754 [BBB] Special Values of Multiple Polylogarithms, J.Borwein, D.Bradley, D.Broadhurst, P.Lisonek, Trans.Amer.Math.Soc. 353/3 (2001), pp. 907-941 [VSW] Numerical evaluation of multiple polylogarithms, J.Vollinga, S.Weinzierl, hep-ph/0410259
The order of parameters and arguments of Li and zeta is defined according to the nested sums representation. The parameters for H are understood as in [ReV]. They can be in expanded — only 0, 1 and -1 — or in compactified — a string with zeros in front of 1 or -1 is written as a single number — notation.
All functions can be numerically evaluated with arguments in the whole complex plane. The parameters for Li, zeta and S must be positive integers. If you want to have an alternating Euler sum, you have to give the signs of the parameters as a second argument s to zeta(m,s) containing 1 and -1.
The calculation of classical polylogarithms is speeded up by using Bernoulli numbers and look-up tables. S uses look-up tables as well. The zeta function applies the algorithms in [Cra] and [BBB] for speed up. Multiple polylogarithms use Hoelder convolution [BBB].
The functions have no means to do a series expansion into nested sums. To do this, you have to convert these functions into the appropriate objects from the nestedsums library, do the expansion and convert the result back.
Numerical testing of this implementation has been performed by doing a comparison of results between this software and the commercial M.......... 4.1. Multiple zeta values have been checked by means of evaluations into simple zeta values. Harmonic polylogarithms have been checked by comparison to S(n,p,x) for corresponding parameter combinations and by continuity checks around |x|=1 along with comparisons to corresponding zeta functions. Multiple polylogarithms were checked against H and zeta and by means of shuffle and quasi-shuffle relations.

Definition in file inifcns_nstdsums.cpp.

Namespaces

Functions

Detailed Description