+ q++;
+ t[j-1] = t[j-1] + cln::expt(x[j-1], q) / cln::expt(cln::cl_I(q),s[j-1]) * one;
+ for (int k=j-2; k>=0; k--) {
+ flag_accidental_zero = cln::zerop(t[k+1]);
+ t[k] = t[k] + t[k+1] * cln::expt(x[k], q+j-1-k) / cln::expt(cln::cl_I(q+j-1-k), s[k]);
+ }
+ } while ( (t[0] != t0buf) || cln::zerop(t[0]) || flag_accidental_zero );
+
+ return t[0];
+}
+
+
+// forward declaration for Li_eval()
+lst convert_parameter_Li_to_H(const lst& m, const lst& x, ex& pf);
+
+
+// type used by the transformation functions for G
+typedef std::vector<int> Gparameter;
+
+
+// G_eval1-function for G transformations
+ex G_eval1(int a, int scale, const exvector& gsyms)
+{
+ if (a != 0) {
+ const ex& scs = gsyms[std::abs(scale)];
+ const ex& as = gsyms[std::abs(a)];
+ if (as != scs) {
+ return -log(1 - scs/as);
+ } else {
+ return -zeta(1);
+ }
+ } else {
+ return log(gsyms[std::abs(scale)]);
+ }
+}
+
+
+// G_eval-function for G transformations
+ex G_eval(const Gparameter& a, int scale, const exvector& gsyms)
+{
+ // check for properties of G
+ ex sc = gsyms[std::abs(scale)];
+ lst newa;
+ bool all_zero = true;
+ bool all_ones = true;
+ int count_ones = 0;
+ for (Gparameter::const_iterator it = a.begin(); it != a.end(); ++it) {
+ if (*it != 0) {
+ const ex sym = gsyms[std::abs(*it)];
+ newa.append(sym);
+ all_zero = false;
+ if (sym != sc) {
+ all_ones = false;
+ }
+ if (all_ones) {
+ ++count_ones;
+ }
+ } else {
+ all_ones = false;
+ }
+ }
+
+ // care about divergent G: shuffle to separate divergencies that will be canceled
+ // later on in the transformation
+ if (newa.nops() > 1 && newa.op(0) == sc && !all_ones && a.front()!=0) {
+ // do shuffle
+ Gparameter short_a;
+ Gparameter::const_iterator it = a.begin();
+ ++it;
+ for (; it != a.end(); ++it) {
+ short_a.push_back(*it);
+ }
+ ex result = G_eval1(a.front(), scale, gsyms) * G_eval(short_a, scale, gsyms);
+ it = short_a.begin();
+ for (int i=1; i<count_ones; ++i) {
+ ++it;
+ }
+ for (; it != short_a.end(); ++it) {
+
+ Gparameter newa;
+ Gparameter::const_iterator it2 = short_a.begin();
+ for (; it2 != it; ++it2) {
+ newa.push_back(*it2);
+ }
+ newa.push_back(*it);
+ newa.push_back(a[0]);
+ it2 = it;
+ ++it2;
+ for (; it2 != short_a.end(); ++it2) {
+ newa.push_back(*it2);
+ }
+ result -= G_eval(newa, scale, gsyms);
+ }
+ return result / count_ones;
+ }
+
+ // G({1,...,1};y) -> G({1};y)^k / k!
+ if (all_ones && a.size() > 1) {
+ return pow(G_eval1(a.front(),scale, gsyms), count_ones) / factorial(count_ones);
+ }
+
+ // G({0,...,0};y) -> log(y)^k / k!
+ if (all_zero) {
+ return pow(log(gsyms[std::abs(scale)]), a.size()) / factorial(a.size());
+ }
+
+ // no special cases anymore -> convert it into Li
+ lst m;
+ lst x;
+ ex argbuf = gsyms[std::abs(scale)];
+ ex mval = _ex1;
+ for (Gparameter::const_iterator it=a.begin(); it!=a.end(); ++it) {
+ if (*it != 0) {
+ const ex& sym = gsyms[std::abs(*it)];
+ x.append(argbuf / sym);
+ m.append(mval);
+ mval = _ex1;
+ argbuf = sym;
+ } else {
+ ++mval;
+ }
+ }
+ return pow(-1, x.nops()) * Li(m, x);
+}
+
+
+// converts data for G: pending_integrals -> a
+Gparameter convert_pending_integrals_G(const Gparameter& pending_integrals)
+{
+ GINAC_ASSERT(pending_integrals.size() != 1);
+
+ if (pending_integrals.size() > 0) {
+ // get rid of the first element, which would stand for the new upper limit
+ Gparameter new_a(pending_integrals.begin()+1, pending_integrals.end());
+ return new_a;
+ } else {
+ // just return empty parameter list
+ Gparameter new_a;
+ return new_a;
+ }
+}
+
+
+// check the parameters a and scale for G and return information about convergence, depth, etc.
+// convergent : true if G(a,scale) is convergent
+// depth : depth of G(a,scale)
+// trailing_zeros : number of trailing zeros of a
+// min_it : iterator of a pointing on the smallest element in a
+Gparameter::const_iterator check_parameter_G(const Gparameter& a, int scale,
+ bool& convergent, int& depth, int& trailing_zeros, Gparameter::const_iterator& min_it)
+{
+ convergent = true;
+ depth = 0;
+ trailing_zeros = 0;
+ min_it = a.end();
+ Gparameter::const_iterator lastnonzero = a.end();
+ for (Gparameter::const_iterator it = a.begin(); it != a.end(); ++it) {
+ if (std::abs(*it) > 0) {
+ ++depth;
+ trailing_zeros = 0;
+ lastnonzero = it;
+ if (std::abs(*it) < scale) {
+ convergent = false;
+ if ((min_it == a.end()) || (std::abs(*it) < std::abs(*min_it))) {
+ min_it = it;
+ }
+ }
+ } else {
+ ++trailing_zeros;
+ }
+ }
+ if (lastnonzero == a.end())
+ return a.end();
+ return ++lastnonzero;
+}
+
+
+// add scale to pending_integrals if pending_integrals is empty
+Gparameter prepare_pending_integrals(const Gparameter& pending_integrals, int scale)
+{
+ GINAC_ASSERT(pending_integrals.size() != 1);
+
+ if (pending_integrals.size() > 0) {
+ return pending_integrals;
+ } else {
+ Gparameter new_pending_integrals;
+ new_pending_integrals.push_back(scale);
+ return new_pending_integrals;
+ }
+}
+
+
+// handles trailing zeroes for an otherwise convergent integral
+ex trailing_zeros_G(const Gparameter& a, int scale, const exvector& gsyms)
+{
+ bool convergent;
+ int depth, trailing_zeros;
+ Gparameter::const_iterator last, dummyit;
+ last = check_parameter_G(a, scale, convergent, depth, trailing_zeros, dummyit);
+
+ GINAC_ASSERT(convergent);
+
+ if ((trailing_zeros > 0) && (depth > 0)) {
+ ex result;
+ Gparameter new_a(a.begin(), a.end()-1);
+ result += G_eval1(0, scale, gsyms) * trailing_zeros_G(new_a, scale, gsyms);
+ for (Gparameter::const_iterator it = a.begin(); it != last; ++it) {
+ Gparameter new_a(a.begin(), it);
+ new_a.push_back(0);
+ new_a.insert(new_a.end(), it, a.end()-1);
+ result -= trailing_zeros_G(new_a, scale, gsyms);
+ }
+
+ return result / trailing_zeros;
+ } else {
+ return G_eval(a, scale, gsyms);
+ }
+}
+
+
+// G transformation [VSW] (57),(58)
+ex depth_one_trafo_G(const Gparameter& pending_integrals, const Gparameter& a, int scale, const exvector& gsyms)
+{
+ // pendint = ( y1, b1, ..., br )
+ // a = ( 0, ..., 0, amin )
+ // scale = y2
+ //
+ // int_0^y1 ds1/(s1-b1) ... int dsr/(sr-br) G(0, ..., 0, sr; y2)
+ // where sr replaces amin
+
+ GINAC_ASSERT(a.back() != 0);
+ GINAC_ASSERT(a.size() > 0);
+
+ ex result;
+ Gparameter new_pending_integrals = prepare_pending_integrals(pending_integrals, std::abs(a.back()));
+ const int psize = pending_integrals.size();
+
+ // length == 1
+ // G(sr_{+-}; y2 ) = G(y2_{-+}; sr) - G(0; sr) + ln(-y2_{-+})
+
+ if (a.size() == 1) {
+
+ // ln(-y2_{-+})
+ result += log(gsyms[ex_to<numeric>(scale).to_int()]);
+ if (a.back() > 0) {
+ new_pending_integrals.push_back(-scale);
+ result += I*Pi;
+ } else {
+ new_pending_integrals.push_back(scale);
+ result -= I*Pi;
+ }
+ if (psize) {
+ result *= trailing_zeros_G(convert_pending_integrals_G(pending_integrals),
+ pending_integrals.front(),
+ gsyms);
+ }
+
+ // G(y2_{-+}; sr)
+ result += trailing_zeros_G(convert_pending_integrals_G(new_pending_integrals),
+ new_pending_integrals.front(),
+ gsyms);
+
+ // G(0; sr)
+ new_pending_integrals.back() = 0;
+ result -= trailing_zeros_G(convert_pending_integrals_G(new_pending_integrals),
+ new_pending_integrals.front(),
+ gsyms);
+
+ return result;
+ }
+
+ // length > 1
+ // G_m(sr_{+-}; y2) = -zeta_m + int_0^y2 dt/t G_{m-1}( (1/y2)_{+-}; 1/t )
+ // - int_0^sr dt/t G_{m-1}( (1/y2)_{+-}; 1/t )
+
+ //term zeta_m
+ result -= zeta(a.size());
+ if (psize) {
+ result *= trailing_zeros_G(convert_pending_integrals_G(pending_integrals),
+ pending_integrals.front(),
+ gsyms);
+ }
+
+ // term int_0^sr dt/t G_{m-1}( (1/y2)_{+-}; 1/t )
+ // = int_0^sr dt/t G_{m-1}( t_{+-}; y2 )
+ Gparameter new_a(a.begin()+1, a.end());
+ new_pending_integrals.push_back(0);
+ result -= depth_one_trafo_G(new_pending_integrals, new_a, scale, gsyms);
+
+ // term int_0^y2 dt/t G_{m-1}( (1/y2)_{+-}; 1/t )
+ // = int_0^y2 dt/t G_{m-1}( t_{+-}; y2 )
+ Gparameter new_pending_integrals_2;
+ new_pending_integrals_2.push_back(scale);
+ new_pending_integrals_2.push_back(0);
+ if (psize) {
+ result += trailing_zeros_G(convert_pending_integrals_G(pending_integrals),
+ pending_integrals.front(),
+ gsyms)
+ * depth_one_trafo_G(new_pending_integrals_2, new_a, scale, gsyms);
+ } else {
+ result += depth_one_trafo_G(new_pending_integrals_2, new_a, scale, gsyms);
+ }
+
+ return result;
+}
+
+
+// forward declaration
+ex shuffle_G(const Gparameter & a0, const Gparameter & a1, const Gparameter & a2,
+ const Gparameter& pendint, const Gparameter& a_old, int scale,
+ const exvector& gsyms, bool flag_trailing_zeros_only);
+
+
+// G transformation [VSW]
+ex G_transform(const Gparameter& pendint, const Gparameter& a, int scale,
+ const exvector& gsyms, bool flag_trailing_zeros_only)
+{
+ // main recursion routine
+ //
+ // pendint = ( y1, b1, ..., br )
+ // a = ( a1, ..., amin, ..., aw )
+ // scale = y2
+ //
+ // int_0^y1 ds1/(s1-b1) ... int dsr/(sr-br) G(a1,...,sr,...,aw,y2)
+ // where sr replaces amin
+
+ // find smallest alpha, determine depth and trailing zeros, and check for convergence
+ bool convergent;
+ int depth, trailing_zeros;
+ Gparameter::const_iterator min_it;
+ Gparameter::const_iterator firstzero =
+ check_parameter_G(a, scale, convergent, depth, trailing_zeros, min_it);
+ int min_it_pos = min_it - a.begin();
+
+ // special case: all a's are zero
+ if (depth == 0) {
+ ex result;
+
+ if (a.size() == 0) {
+ result = 1;
+ } else {
+ result = G_eval(a, scale, gsyms);
+ }
+ if (pendint.size() > 0) {
+ result *= trailing_zeros_G(convert_pending_integrals_G(pendint),
+ pendint.front(),
+ gsyms);
+ }
+ return result;
+ }
+
+ // handle trailing zeros
+ if (trailing_zeros > 0) {
+ ex result;
+ Gparameter new_a(a.begin(), a.end()-1);
+ result += G_eval1(0, scale, gsyms) * G_transform(pendint, new_a, scale, gsyms, flag_trailing_zeros_only);
+ for (Gparameter::const_iterator it = a.begin(); it != firstzero; ++it) {
+ Gparameter new_a(a.begin(), it);
+ new_a.push_back(0);
+ new_a.insert(new_a.end(), it, a.end()-1);
+ result -= G_transform(pendint, new_a, scale, gsyms, flag_trailing_zeros_only);
+ }
+ return result / trailing_zeros;
+ }
+
+ // convergence case or flag_trailing_zeros_only
+ if (convergent || flag_trailing_zeros_only) {
+ if (pendint.size() > 0) {
+ return G_eval(convert_pending_integrals_G(pendint),
+ pendint.front(), gsyms)*
+ G_eval(a, scale, gsyms);
+ } else {
+ return G_eval(a, scale, gsyms);
+ }
+ }
+
+ // call basic transformation for depth equal one
+ if (depth == 1) {
+ return depth_one_trafo_G(pendint, a, scale, gsyms);
+ }
+
+ // do recursion
+ // int_0^y1 ds1/(s1-b1) ... int dsr/(sr-br) G(a1,...,sr,...,aw,y2)
+ // = int_0^y1 ds1/(s1-b1) ... int dsr/(sr-br) G(a1,...,0,...,aw,y2)
+ // + int_0^y1 ds1/(s1-b1) ... int dsr/(sr-br) int_0^{sr} ds_{r+1} d/ds_{r+1} G(a1,...,s_{r+1},...,aw,y2)
+
+ // smallest element in last place
+ if (min_it + 1 == a.end()) {
+ do { --min_it; } while (*min_it == 0);
+ Gparameter empty;
+ Gparameter a1(a.begin(),min_it+1);
+ Gparameter a2(min_it+1,a.end());
+
+ ex result = G_transform(pendint, a2, scale, gsyms, flag_trailing_zeros_only)*
+ G_transform(empty, a1, scale, gsyms, flag_trailing_zeros_only);
+
+ result -= shuffle_G(empty, a1, a2, pendint, a, scale, gsyms, flag_trailing_zeros_only);
+ return result;
+ }
+
+ Gparameter empty;
+ Gparameter::iterator changeit;
+
+ // first term G(a_1,..,0,...,a_w;a_0)
+ Gparameter new_pendint = prepare_pending_integrals(pendint, a[min_it_pos]);
+ Gparameter new_a = a;
+ new_a[min_it_pos] = 0;
+ ex result = G_transform(empty, new_a, scale, gsyms, flag_trailing_zeros_only);
+ if (pendint.size() > 0) {
+ result *= trailing_zeros_G(convert_pending_integrals_G(pendint),
+ pendint.front(), gsyms);
+ }
+
+ // other terms
+ changeit = new_a.begin() + min_it_pos;
+ changeit = new_a.erase(changeit);
+ if (changeit != new_a.begin()) {
+ // smallest in the middle
+ new_pendint.push_back(*changeit);
+ result -= trailing_zeros_G(convert_pending_integrals_G(new_pendint),
+ new_pendint.front(), gsyms)*
+ G_transform(empty, new_a, scale, gsyms, flag_trailing_zeros_only);
+ int buffer = *changeit;
+ *changeit = *min_it;
+ result += G_transform(new_pendint, new_a, scale, gsyms, flag_trailing_zeros_only);
+ *changeit = buffer;
+ new_pendint.pop_back();
+ --changeit;
+ new_pendint.push_back(*changeit);
+ result += trailing_zeros_G(convert_pending_integrals_G(new_pendint),
+ new_pendint.front(), gsyms)*
+ G_transform(empty, new_a, scale, gsyms, flag_trailing_zeros_only);
+ *changeit = *min_it;
+ result -= G_transform(new_pendint, new_a, scale, gsyms, flag_trailing_zeros_only);
+ } else {
+ // smallest at the front
+ new_pendint.push_back(scale);
+ result += trailing_zeros_G(convert_pending_integrals_G(new_pendint),
+ new_pendint.front(), gsyms)*
+ G_transform(empty, new_a, scale, gsyms, flag_trailing_zeros_only);
+ new_pendint.back() = *changeit;
+ result -= trailing_zeros_G(convert_pending_integrals_G(new_pendint),
+ new_pendint.front(), gsyms)*
+ G_transform(empty, new_a, scale, gsyms, flag_trailing_zeros_only);
+ *changeit = *min_it;
+ result += G_transform(new_pendint, new_a, scale, gsyms, flag_trailing_zeros_only);
+ }
+ return result;
+}
+
+
+// shuffles the two parameter list a1 and a2 and calls G_transform for every term except
+// for the one that is equal to a_old
+ex shuffle_G(const Gparameter & a0, const Gparameter & a1, const Gparameter & a2,
+ const Gparameter& pendint, const Gparameter& a_old, int scale,
+ const exvector& gsyms, bool flag_trailing_zeros_only)
+{
+ if (a1.size()==0 && a2.size()==0) {
+ // veto the one configuration we don't want
+ if ( a0 == a_old ) return 0;
+
+ return G_transform(pendint, a0, scale, gsyms, flag_trailing_zeros_only);
+ }
+
+ if (a2.size()==0) {
+ Gparameter empty;
+ Gparameter aa0 = a0;
+ aa0.insert(aa0.end(),a1.begin(),a1.end());
+ return shuffle_G(aa0, empty, empty, pendint, a_old, scale, gsyms, flag_trailing_zeros_only);
+ }
+
+ if (a1.size()==0) {
+ Gparameter empty;
+ Gparameter aa0 = a0;
+ aa0.insert(aa0.end(),a2.begin(),a2.end());
+ return shuffle_G(aa0, empty, empty, pendint, a_old, scale, gsyms, flag_trailing_zeros_only);
+ }
+
+ Gparameter a1_removed(a1.begin()+1,a1.end());
+ Gparameter a2_removed(a2.begin()+1,a2.end());
+
+ Gparameter a01 = a0;
+ Gparameter a02 = a0;
+
+ a01.push_back( a1[0] );
+ a02.push_back( a2[0] );
+
+ return shuffle_G(a01, a1_removed, a2, pendint, a_old, scale, gsyms, flag_trailing_zeros_only)
+ + shuffle_G(a02, a1, a2_removed, pendint, a_old, scale, gsyms, flag_trailing_zeros_only);
+}
+
+// handles the transformations and the numerical evaluation of G
+// the parameter x, s and y must only contain numerics
+static cln::cl_N
+G_numeric(const std::vector<cln::cl_N>& x, const std::vector<int>& s,
+ const cln::cl_N& y);
+
+// do acceleration transformation (hoelder convolution [BBB])
+// the parameter x, s and y must only contain numerics
+static cln::cl_N
+G_do_hoelder(std::vector<cln::cl_N> x, /* yes, it's passed by value */
+ const std::vector<int>& s, const cln::cl_N& y)
+{
+ cln::cl_N result;
+ const std::size_t size = x.size();
+ for (std::size_t i = 0; i < size; ++i)
+ x[i] = x[i]/y;
+
+ for (std::size_t r = 0; r <= size; ++r) {
+ cln::cl_N buffer(1 & r ? -1 : 1);
+ cln::cl_RA p(2);
+ bool adjustp;
+ do {
+ adjustp = false;
+ for (std::size_t i = 0; i < size; ++i) {
+ if (x[i] == cln::cl_RA(1)/p) {
+ p = p/2 + cln::cl_RA(3)/2;
+ adjustp = true;
+ continue;
+ }
+ }
+ } while (adjustp);
+ cln::cl_RA q = p/(p-1);
+ std::vector<cln::cl_N> qlstx;
+ std::vector<int> qlsts;
+ for (std::size_t j = r; j >= 1; --j) {
+ qlstx.push_back(cln::cl_N(1) - x[j-1]);
+ if (instanceof(x[j-1], cln::cl_R_ring) && realpart(x[j-1]) > 1) {
+ qlsts.push_back(1);
+ } else {
+ qlsts.push_back(-s[j-1]);
+ }
+ }
+ if (qlstx.size() > 0) {
+ buffer = buffer*G_numeric(qlstx, qlsts, 1/q);
+ }
+ std::vector<cln::cl_N> plstx;
+ std::vector<int> plsts;
+ for (std::size_t j = r+1; j <= size; ++j) {
+ plstx.push_back(x[j-1]);
+ plsts.push_back(s[j-1]);
+ }
+ if (plstx.size() > 0) {
+ buffer = buffer*G_numeric(plstx, plsts, 1/p);
+ }
+ result = result + buffer;
+ }
+ return result;
+}
+
+class less_object_for_cl_N
+{
+public:
+ bool operator() (const cln::cl_N & a, const cln::cl_N & b) const
+ {
+ // absolute value?
+ if (abs(a) != abs(b))
+ return (abs(a) < abs(b)) ? true : false;
+
+ // complex phase?
+ if (phase(a) != phase(b))
+ return (phase(a) < phase(b)) ? true : false;
+
+ // equal, therefore "less" is not true
+ return false;
+ }
+};
+
+
+// convergence transformation, used for numerical evaluation of G function.
+// the parameter x, s and y must only contain numerics
+static cln::cl_N
+G_do_trafo(const std::vector<cln::cl_N>& x, const std::vector<int>& s,
+ const cln::cl_N& y, bool flag_trailing_zeros_only)
+{
+ // sort (|x|<->position) to determine indices
+ typedef std::multimap<cln::cl_N, std::size_t, less_object_for_cl_N> sortmap_t;
+ sortmap_t sortmap;
+ std::size_t size = 0;
+ for (std::size_t i = 0; i < x.size(); ++i) {
+ if (!zerop(x[i])) {
+ sortmap.insert(std::make_pair(x[i], i));
+ ++size;
+ }
+ }
+ // include upper limit (scale)
+ sortmap.insert(std::make_pair(y, x.size()));
+
+ // generate missing dummy-symbols
+ int i = 1;
+ // holding dummy-symbols for the G/Li transformations
+ exvector gsyms;
+ gsyms.push_back(symbol("GSYMS_ERROR"));
+ cln::cl_N lastentry(0);
+ for (sortmap_t::const_iterator it = sortmap.begin(); it != sortmap.end(); ++it) {
+ if (it != sortmap.begin()) {
+ if (it->second < x.size()) {
+ if (x[it->second] == lastentry) {
+ gsyms.push_back(gsyms.back());
+ continue;
+ }
+ } else {
+ if (y == lastentry) {
+ gsyms.push_back(gsyms.back());
+ continue;
+ }
+ }
+ }
+ std::ostringstream os;
+ os << "a" << i;
+ gsyms.push_back(symbol(os.str()));
+ ++i;
+ if (it->second < x.size()) {
+ lastentry = x[it->second];
+ } else {
+ lastentry = y;
+ }
+ }
+
+ // fill position data according to sorted indices and prepare substitution list
+ Gparameter a(x.size());
+ exmap subslst;
+ std::size_t pos = 1;
+ int scale = pos;
+ for (sortmap_t::const_iterator it = sortmap.begin(); it != sortmap.end(); ++it) {
+ if (it->second < x.size()) {
+ if (s[it->second] > 0) {
+ a[it->second] = pos;
+ } else {
+ a[it->second] = -int(pos);
+ }
+ subslst[gsyms[pos]] = numeric(x[it->second]);
+ } else {
+ scale = pos;
+ subslst[gsyms[pos]] = numeric(y);
+ }
+ ++pos;
+ }
+
+ // do transformation
+ Gparameter pendint;
+ ex result = G_transform(pendint, a, scale, gsyms, flag_trailing_zeros_only);
+ // replace dummy symbols with their values
+ result = result.expand();
+ result = result.subs(subslst).evalf();
+ if (!is_a<numeric>(result))
+ throw std::logic_error("G_do_trafo: G_transform returned non-numeric result");
+
+ cln::cl_N ret = ex_to<numeric>(result).to_cl_N();
+ return ret;
+}
+
+// handles the transformations and the numerical evaluation of G
+// the parameter x, s and y must only contain numerics
+static cln::cl_N
+G_numeric(const std::vector<cln::cl_N>& x, const std::vector<int>& s,
+ const cln::cl_N& y)
+{
+ // check for convergence and necessary accelerations
+ bool need_trafo = false;
+ bool need_hoelder = false;
+ bool have_trailing_zero = false;
+ std::size_t depth = 0;
+ for (std::size_t i = 0; i < x.size(); ++i) {
+ if (!zerop(x[i])) {
+ ++depth;
+ const cln::cl_N x_y = abs(x[i]) - y;
+ if (instanceof(x_y, cln::cl_R_ring) &&
+ realpart(x_y) < cln::least_negative_float(cln::float_format(Digits - 2)))
+ need_trafo = true;
+
+ if (abs(abs(x[i]/y) - 1) < 0.01)
+ need_hoelder = true;
+ }
+ }
+ if (zerop(x.back())) {
+ have_trailing_zero = true;
+ need_trafo = true;
+ }
+
+ if (depth == 1 && x.size() == 2 && !need_trafo)
+ return - Li_projection(2, y/x[1], cln::float_format(Digits));
+
+ // do acceleration transformation (hoelder convolution [BBB])
+ if (need_hoelder && !have_trailing_zero)
+ return G_do_hoelder(x, s, y);
+
+ // convergence transformation
+ if (need_trafo)
+ return G_do_trafo(x, s, y, have_trailing_zero);
+
+ // do summation
+ std::vector<cln::cl_N> newx;
+ newx.reserve(x.size());
+ std::vector<int> m;
+ m.reserve(x.size());
+ int mcount = 1;
+ int sign = 1;
+ cln::cl_N factor = y;
+ for (std::size_t i = 0; i < x.size(); ++i) {
+ if (zerop(x[i])) {
+ ++mcount;
+ } else {
+ newx.push_back(factor/x[i]);
+ factor = x[i];
+ m.push_back(mcount);
+ mcount = 1;
+ sign = -sign;
+ }
+ }
+
+ return sign*multipleLi_do_sum(m, newx);
+}
+
+
+ex mLi_numeric(const lst& m, const lst& x)
+{
+ // let G_numeric do the transformation
+ std::vector<cln::cl_N> newx;
+ newx.reserve(x.nops());
+ std::vector<int> s;
+ s.reserve(x.nops());
+ cln::cl_N factor(1);
+ for (lst::const_iterator itm = m.begin(), itx = x.begin(); itm != m.end(); ++itm, ++itx) {
+ for (int i = 1; i < *itm; ++i) {
+ newx.push_back(cln::cl_N(0));
+ s.push_back(1);
+ }
+ const cln::cl_N xi = ex_to<numeric>(*itx).to_cl_N();
+ factor = factor/xi;
+ newx.push_back(factor);
+ if ( !instanceof(factor, cln::cl_R_ring) && imagpart(factor) < 0 ) {
+ s.push_back(-1);
+ }
+ else {
+ s.push_back(1);
+ }
+ }
+ return numeric(cln::cl_N(1 & m.nops() ? - 1 : 1)*G_numeric(newx, s, cln::cl_N(1)));
+}
+
+
+} // end of anonymous namespace
+
+
+//////////////////////////////////////////////////////////////////////
+//
+// Generalized multiple polylogarithm G(x, y) and G(x, s, y)
+//
+// GiNaC function
+//
+//////////////////////////////////////////////////////////////////////
+
+
+static ex G2_evalf(const ex& x_, const ex& y)
+{
+ if ((!y.info(info_flags::numeric)) || (!y.info(info_flags::positive))) {
+ return G(x_, y).hold();
+ }
+ lst x = is_a<lst>(x_) ? ex_to<lst>(x_) : lst{x_};
+ if (x.nops() == 0) {
+ return _ex1;
+ }
+ if (x.op(0) == y) {
+ return G(x_, y).hold();
+ }
+ std::vector<int> s;
+ s.reserve(x.nops());
+ bool all_zero = true;
+ for (lst::const_iterator it = x.begin(); it != x.end(); ++it) {
+ if (!(*it).info(info_flags::numeric)) {
+ return G(x_, y).hold();
+ }
+ if (*it != _ex0) {
+ all_zero = false;
+ }
+ if ( !ex_to<numeric>(*it).is_real() && ex_to<numeric>(*it).imag() < 0 ) {
+ s.push_back(-1);
+ }
+ else {
+ s.push_back(1);
+ }
+ }
+ if (all_zero) {
+ return pow(log(y), x.nops()) / factorial(x.nops());
+ }
+ std::vector<cln::cl_N> xv;
+ xv.reserve(x.nops());
+ for (lst::const_iterator it = x.begin(); it != x.end(); ++it)
+ xv.push_back(ex_to<numeric>(*it).to_cl_N());
+ cln::cl_N result = G_numeric(xv, s, ex_to<numeric>(y).to_cl_N());
+ return numeric(result);
+}
+
+
+static ex G2_eval(const ex& x_, const ex& y)
+{
+ //TODO eval to MZV or H or S or Lin
+
+ if ((!y.info(info_flags::numeric)) || (!y.info(info_flags::positive))) {
+ return G(x_, y).hold();
+ }
+ lst x = is_a<lst>(x_) ? ex_to<lst>(x_) : lst{x_};
+ if (x.nops() == 0) {
+ return _ex1;
+ }
+ if (x.op(0) == y) {
+ return G(x_, y).hold();
+ }
+ std::vector<int> s;
+ s.reserve(x.nops());
+ bool all_zero = true;
+ bool crational = true;
+ for (lst::const_iterator it = x.begin(); it != x.end(); ++it) {
+ if (!(*it).info(info_flags::numeric)) {
+ return G(x_, y).hold();
+ }
+ if (!(*it).info(info_flags::crational)) {
+ crational = false;
+ }
+ if (*it != _ex0) {
+ all_zero = false;
+ }
+ if ( !ex_to<numeric>(*it).is_real() && ex_to<numeric>(*it).imag() < 0 ) {
+ s.push_back(-1);
+ }
+ else {
+ s.push_back(+1);
+ }
+ }
+ if (all_zero) {
+ return pow(log(y), x.nops()) / factorial(x.nops());
+ }
+ if (!y.info(info_flags::crational)) {
+ crational = false;
+ }
+ if (crational) {
+ return G(x_, y).hold();
+ }
+ std::vector<cln::cl_N> xv;
+ xv.reserve(x.nops());
+ for (lst::const_iterator it = x.begin(); it != x.end(); ++it)
+ xv.push_back(ex_to<numeric>(*it).to_cl_N());
+ cln::cl_N result = G_numeric(xv, s, ex_to<numeric>(y).to_cl_N());
+ return numeric(result);
+}
+
+
+// option do_not_evalf_params() removed.
+unsigned G2_SERIAL::serial = function::register_new(function_options("G", 2).
+ evalf_func(G2_evalf).
+ eval_func(G2_eval).
+ overloaded(2));
+//TODO
+// derivative_func(G2_deriv).
+// print_func<print_latex>(G2_print_latex).
+
+
+static ex G3_evalf(const ex& x_, const ex& s_, const ex& y)
+{
+ if ((!y.info(info_flags::numeric)) || (!y.info(info_flags::positive))) {
+ return G(x_, s_, y).hold();
+ }
+ lst x = is_a<lst>(x_) ? ex_to<lst>(x_) : lst{x_};
+ lst s = is_a<lst>(s_) ? ex_to<lst>(s_) : lst{s_};
+ if (x.nops() != s.nops()) {
+ return G(x_, s_, y).hold();
+ }
+ if (x.nops() == 0) {
+ return _ex1;
+ }
+ if (x.op(0) == y) {
+ return G(x_, s_, y).hold();
+ }
+ std::vector<int> sn;
+ sn.reserve(s.nops());
+ bool all_zero = true;
+ for (lst::const_iterator itx = x.begin(), its = s.begin(); itx != x.end(); ++itx, ++its) {
+ if (!(*itx).info(info_flags::numeric)) {
+ return G(x_, y).hold();
+ }
+ if (!(*its).info(info_flags::real)) {
+ return G(x_, y).hold();
+ }
+ if (*itx != _ex0) {
+ all_zero = false;
+ }
+ if ( ex_to<numeric>(*itx).is_real() ) {
+ if ( ex_to<numeric>(*itx).is_positive() ) {
+ if ( *its >= 0 ) {
+ sn.push_back(1);
+ }
+ else {
+ sn.push_back(-1);
+ }
+ } else {
+ sn.push_back(1);
+ }
+ }
+ else {
+ if ( ex_to<numeric>(*itx).imag() > 0 ) {
+ sn.push_back(1);
+ }
+ else {
+ sn.push_back(-1);
+ }
+ }
+ }
+ if (all_zero) {
+ return pow(log(y), x.nops()) / factorial(x.nops());
+ }
+ std::vector<cln::cl_N> xn;
+ xn.reserve(x.nops());
+ for (lst::const_iterator it = x.begin(); it != x.end(); ++it)
+ xn.push_back(ex_to<numeric>(*it).to_cl_N());
+ cln::cl_N result = G_numeric(xn, sn, ex_to<numeric>(y).to_cl_N());
+ return numeric(result);
+}
+
+
+static ex G3_eval(const ex& x_, const ex& s_, const ex& y)
+{
+ //TODO eval to MZV or H or S or Lin
+
+ if ((!y.info(info_flags::numeric)) || (!y.info(info_flags::positive))) {
+ return G(x_, s_, y).hold();
+ }
+ lst x = is_a<lst>(x_) ? ex_to<lst>(x_) : lst{x_};
+ lst s = is_a<lst>(s_) ? ex_to<lst>(s_) : lst{s_};
+ if (x.nops() != s.nops()) {
+ return G(x_, s_, y).hold();
+ }
+ if (x.nops() == 0) {
+ return _ex1;
+ }
+ if (x.op(0) == y) {
+ return G(x_, s_, y).hold();
+ }
+ std::vector<int> sn;
+ sn.reserve(s.nops());
+ bool all_zero = true;
+ bool crational = true;
+ for (lst::const_iterator itx = x.begin(), its = s.begin(); itx != x.end(); ++itx, ++its) {
+ if (!(*itx).info(info_flags::numeric)) {
+ return G(x_, s_, y).hold();
+ }
+ if (!(*its).info(info_flags::real)) {
+ return G(x_, s_, y).hold();