* 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 nummerically evaluated with arguments in the whole complex plane. The parameters
+ * - 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.
*
// lookup table for factors built from Bernoulli numbers
// see fill_Xn()
-std::vector<std::vector<cln::cl_N> > Xn;
+std::vector<std::vector<cln::cl_N>> Xn;
// initial size of Xn that should suffice for 32bit machines (must be even)
const int xninitsizestep = 26;
int xninitsize = xninitsizestep;
{
if (is_a<lst>(m) || is_a<lst>(x)) {
// multiple polylog
- epvector seq;
- seq.push_back(expair(Li(m, x), 0));
- return pseries(rel, seq);
+ epvector seq { expair(Li(m, x), 0) };
+ return pseries(rel, std::move(seq));
}
// classical polylog
// substitute the argument's series expansion
ser = ser.subs(s==x.series(rel, order), subs_options::no_pattern);
// maybe that was terminating, so add a proper order term
- epvector nseq;
- nseq.push_back(expair(Order(_ex1), order));
- ser += pseries(rel, nseq);
+ epvector nseq { expair(Order(_ex1), order) };
+ ser += pseries(rel, std::move(nseq));
// reexpanding it will collapse the series again
return ser.series(rel, order);
}
// lookup table for special Euler-Zagier-Sums (used for S_n,p(x))
// see fill_Yn()
-std::vector<std::vector<cln::cl_N> > Yn;
+std::vector<std::vector<cln::cl_N>> Yn;
int ynsize = 0; // number of Yn[]
int ynlength = 100; // initial length of all Yn[i]
// substitute the argument's series expansion
ser = ser.subs(s==x.series(rel, order), subs_options::no_pattern);
// maybe that was terminating, so add a proper order term
- epvector nseq;
- nseq.push_back(expair(Order(_ex1), order));
- ser += pseries(rel, nseq);
+ epvector nseq { expair(Order(_ex1), order) };
+ ser += pseries(rel, std::move(nseq));
// reexpanding it will collapse the series again
return ser.series(rel, order);
}
// recursivly transforms H to corresponding multiple polylogarithms
struct map_trafo_H_convert_to_Li : public map_function
{
- ex operator()(const ex& e)
+ ex operator()(const ex& e) override
{
if (is_a<add>(e) || is_a<mul>(e)) {
return e.map(*this);
// recursivly transforms H to corresponding zetas
struct map_trafo_H_convert_to_zeta : public map_function
{
- ex operator()(const ex& e)
+ ex operator()(const ex& e) override
{
if (is_a<add>(e) || is_a<mul>(e)) {
return e.map(*this);
// remove trailing zeros from H-parameters
struct map_trafo_H_reduce_trailing_zeros : public map_function
{
- ex operator()(const ex& e)
+ ex operator()(const ex& e) override
{
if (is_a<add>(e) || is_a<mul>(e)) {
return e.map(*this);
// applies trafo_H_mult recursively on expressions
struct map_trafo_H_mult : public map_function
{
- ex operator()(const ex& e)
+ ex operator()(const ex& e) override
{
if (is_a<add>(e)) {
return e.map(*this);
// do x -> 1-x transformation
struct map_trafo_H_1mx : public map_function
{
- ex operator()(const ex& e)
+ ex operator()(const ex& e) override
{
if (is_a<add>(e) || is_a<mul>(e)) {
return e.map(*this);
// do x -> 1/x transformation
struct map_trafo_H_1overx : public map_function
{
- ex operator()(const ex& e)
+ ex operator()(const ex& e) override
{
if (is_a<add>(e) || is_a<mul>(e)) {
return e.map(*this);
// do x -> (1-x)/(1+x) transformation
struct map_trafo_H_1mxt1px : public map_function
{
- ex operator()(const ex& e)
+ ex operator()(const ex& e) override
{
if (is_a<add>(e) || is_a<mul>(e)) {
return e.map(*this);
static ex H_series(const ex& m, const ex& x, const relational& rel, int order, unsigned options)
{
- epvector seq;
- seq.push_back(expair(H(m, x), 0));
- return pseries(rel, seq);
+ epvector seq { expair(H(m, x), 0) };
+ return pseries(rel, std::move(seq));
}
int Sm = 0;
int Smp1 = 0;
- std::vector<std::vector<cln::cl_N> > crG(s.size() - 1, std::vector<cln::cl_N>(L2 + 1));
+ std::vector<std::vector<cln::cl_N>> crG(s.size() - 1, std::vector<cln::cl_N>(L2 + 1));
for (int m=0; m < (int)s.size() - 1; m++) {
Sm += s[m];
Smp1 = Sm + s[m+1];
// [Cra] section 4
-static void calc_f(std::vector<std::vector<cln::cl_N> >& f_kj,
+static void calc_f(std::vector<std::vector<cln::cl_N>>& f_kj,
const int maxr, const int L1)
{
cln::cl_N t0, t1, t2, t3, t4;
int i, j, k;
- std::vector<std::vector<cln::cl_N> >::iterator it = f_kj.begin();
+ std::vector<std::vector<cln::cl_N>>::iterator it = f_kj.begin();
cln::cl_F one = cln::cl_float(1, cln::float_format(Digits));
t0 = cln::exp(-lambda);
// [Cra] (3.1)
static cln::cl_N crandall_Z(const std::vector<int>& s,
- const std::vector<std::vector<cln::cl_N> >& f_kj)
+ const std::vector<std::vector<cln::cl_N>>& f_kj)
{
const int j = s.size();
}
}
- std::vector<std::vector<cln::cl_N> > f_kj(L1);
+ std::vector<std::vector<cln::cl_N>> f_kj(L1);
calc_f(f_kj, maxr, L1);
const cln::cl_N r0factorial = cln::factorial(r[0]-1);