From d86fe125a638182856a09922b87f6a972e96c3a0 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 1 Jul 2021 13:08:53 +0200 Subject: [PATCH 01/71] Init backward_paper --- backward_paper/.gitignore | 118 ++++++++++++++++++++++++++++++ backward_paper/banana.yaml | 5 ++ backward_paper/evolve_backward.py | 107 +++++++++++++++++++++++++++ 3 files changed, 230 insertions(+) create mode 100644 backward_paper/.gitignore create mode 100644 backward_paper/banana.yaml create mode 100644 backward_paper/evolve_backward.py diff --git a/backward_paper/.gitignore b/backward_paper/.gitignore new file mode 100644 index 000000000..6876ce0bf --- /dev/null +++ b/backward_paper/.gitignore @@ -0,0 +1,118 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# VS Code +.vscode + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +assets/ + +# mypy +.mypy_cache/ + +# yaml +*.yaml + +# database +*.db + +# pdfs +*.pdf \ No newline at end of file diff --git a/backward_paper/banana.yaml b/backward_paper/banana.yaml new file mode 100644 index 000000000..13dfa8952 --- /dev/null +++ b/backward_paper/banana.yaml @@ -0,0 +1,5 @@ +database_path: benchmark.db +input_tables: + - theories + - operators + - cache diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py new file mode 100644 index 000000000..3bc30d37c --- /dev/null +++ b/backward_paper/evolve_backward.py @@ -0,0 +1,107 @@ +# -*- coding: utf-8 -*- +""" +This script compute an EKO to evolve a PDF set under the charm thrshold replica by replica +""" +import logging +import pathlib +import os +import sys + +from banana import load_config +from banana.benchmark.runner import BenchmarkRunner + +from ekomark.data import operators, db +import eko + +pkg_path = pathlib.Path(__file__).absolute().parents[0] + + +class Runner(BenchmarkRunner): + """ + EKO specialization of the banana runner. + """ + + banana_cfg = load_config(pkg_path) + db_base_cls = db.Base + rotate_to_evolution_basis = False + + @staticmethod + def load_ocards(session, ocard_updates): + return operators.load(session, ocard_updates) + + def run_external(self, theory, ocard, pdf): + pass + + def run_me(self, theory, ocard, _pdf): + """ + Run eko + + Parameters + ---------- + theory : dict + theory card + ocard : dict + operator card + + Returns + ------- + out : dict + DGLAP result + """ + + # activate logging + logStdout = logging.StreamHandler(sys.stdout) + logStdout.setLevel(logging.INFO) + logStdout.setFormatter(logging.Formatter("%(message)s")) + logging.getLogger("eko").handlers = [] + logging.getLogger("eko").addHandler(logStdout) + logging.getLogger("eko").setLevel(logging.INFO) + + ops_id = f"o{ocard['hash'][:6]}_t{theory['hash'][:6]}" + path = f"{self.banana_cfg['database_path'].parents[0]}/{ops_id}.yaml" + rerun = True + if os.path.exists(path): + rerun = False + ask = input("Use cached output? [Y/n]") + if ask.lower() in ["n", "no"]: + rerun = True + + if rerun: + out = eko.run_dglap(theory, ocard) + print(f"Writing operator to {path}") + out.dump_yaml_to_file(path) + else: + print(f"Using cached eko data: {os.path.relpath(path,os.getcwd())}") + with open(path) as o: + out = eko.output.Output.load_yaml(o) + + return out + + def log(self, theory, ocard, pdf, me, ext): + # TODO: combine here the eko with pdf replicas + # and then plot + pass + + +if __name__ == "__main__": + + backward_runner = Runner() + # TODO: add here the correct parameters + theory_updates = { + "Qref": 91.2, + "alphas": 0.118000, + "mc": 1.51, + "mb": 4.92, + "mt": 172.5, + "kcThr": 1.0, + "kbThr": 1.0, + "ktThr": 1.0, + "PTO": 1, + "Q0": 1.7, + } + operator_updates = { + "Q2grid": [1.5], + "backward_inversion": "exact", + } + + backward_runner.run([theory_updates], [operator_updates], ["ToyLH"]) From 96b150a7bb5242e2348784004b87fc85260492e0 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 1 Jul 2021 17:48:52 +0200 Subject: [PATCH 02/71] add simple plotiing --- backward_paper/evolve_backward.py | 103 +++++++++++++++++++++++++++--- 1 file changed, 95 insertions(+), 8 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 3bc30d37c..adbe8f2e5 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -2,20 +2,63 @@ """ This script compute an EKO to evolve a PDF set under the charm thrshold replica by replica """ +import functools import logging import pathlib import os import sys +import pandas as pd +import numpy as np from banana import load_config from banana.benchmark.runner import BenchmarkRunner +from banana.data import dfdict from ekomark.data import operators, db +from ekomark import pdfname +from eko import basis_rotation as br + import eko +import lhapdf + +from matplotlib import use, rc +import matplotlib.pyplot as plt +from matplotlib.backends.backend_pdf import PdfPages + + +use("PDF") +rc("font", **{"family": "sans-serif", "sans-serif": ["Helvetica"]}) +rc("text", usetex=True) pkg_path = pathlib.Path(__file__).absolute().parents[0] +def plot_pdf(log, pdf_name): + + path = pkg_path / f"{pdf_name}.pdf" + print(f"Writing pdf plots to {path}") + + with PdfPages(path) as pp: + for name, vals in log.items(): + + fig = plt.figure(figsize=(15, 5)) + plt.title(name) + + mean = vals.groupby(['x'], axis=0, as_index=False).mean() + std = vals.groupby(['x'], axis=0, as_index=False).std() + mean.plot('x', 'eko') + plt.fill_between(std.x, mean.eko - std.eko, mean.eko + std.eko, alpha=0.2) + + plt.xscale("log") + plt.ylabel(r"$\rm{ x%s(x)}$"%name, fontsize=11) + plt.xlabel("x") + plt.plot(np.geomspace(1e-7,1,200), np.zeros(200), "k--", alpha=0.7) + #plt.legend(f"{pdf_name} @ 1.5 GeV") + plt.tight_layout() + + pp.savefig() + plt.close(fig) + class Runner(BenchmarkRunner): """ EKO specialization of the banana runner. @@ -24,6 +67,8 @@ class Runner(BenchmarkRunner): banana_cfg = load_config(pkg_path) db_base_cls = db.Base rotate_to_evolution_basis = False + pdf_name="NNPDF31_nnlo_as_0118" + skip_pdfs=[5,-5,-6,6,22] @staticmethod def load_ocards(session, ocard_updates): @@ -77,16 +122,57 @@ def run_me(self, theory, ocard, _pdf): return out - def log(self, theory, ocard, pdf, me, ext): - # TODO: combine here the eko with pdf replicas - # and then plot - pass + def log(self, _theory, ocard, _pdf, me, _ext): + + log_tabs = {} + xgrid = ocard["interpolation_xgrid"] + # assume to have just one q2 in the grid + q2 = ocard["Q2grid"][0] + + rotate_to_evolution = None + if self.rotate_to_evolution_basis: + rotate_to_evolution = br.rotate_flavor_to_evolution.copy() + + pdfs = lhapdf.mkPDFs(self.pdf_name) + + # Loop over pdfs replicas + for rep, pdf in enumerate(pdfs): + pdf_grid = me.apply_pdf_flavor( + pdf, + xgrid, + flavor_rotation=rotate_to_evolution, + ) + + log_tab = dfdict.DFdict() + #ref_pdfs = ext["values"][q2] + res = pdf_grid[q2] + my_pdfs = res["pdfs"] + my_pdf_errs = res["errors"] + + for key in my_pdfs: + if key in self.skip_pdfs: + continue + # build table + tab = {} + tab["x"] = xgrid + tab["Q2"] = q2 + tab["eko"] = xgrid * my_pdfs[key] + tab["eko_error"] = xgrid * my_pdf_errs[key] + #tab[self.external] = r = ref_pdfs[key] + #tab["percent_error"] = (f - r) / r * 100 + + log_tab[pdfname(key)] = pd.DataFrame(tab) + log_tabs[rep] = log_tab + + # Plot + new_log = functools.reduce(lambda dfd1, dfd2: dfd1.merge(dfd2), log_tabs.values()) + plot_pdf(new_log, self.pdf_name) + return new_log if __name__ == "__main__": backward_runner = Runner() - # TODO: add here the correct parameters theory_updates = { "Qref": 91.2, "alphas": 0.118000, @@ -96,12 +182,13 @@ def log(self, theory, ocard, pdf, me, ext): "kcThr": 1.0, "kbThr": 1.0, "ktThr": 1.0, - "PTO": 1, - "Q0": 1.7, + "PTO": 2, + "Q0": 1.65, } operator_updates = { "Q2grid": [1.5], "backward_inversion": "exact", } - + + # toyLH is not used in log backward_runner.run([theory_updates], [operator_updates], ["ToyLH"]) From d14f3e2d1200b7d55c0fc166d235dcf760d3099c Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 5 Jul 2021 10:54:18 +0200 Subject: [PATCH 03/71] Improve plotting --- backward_paper/evolve_backward.py | 115 +++++++++++++++++++++--------- 1 file changed, 83 insertions(+), 32 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index adbe8f2e5..78026cede 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -16,15 +16,13 @@ from ekomark.data import operators, db from ekomark import pdfname -from eko import basis_rotation as br - -import eko -import lhapdf from matplotlib import use, rc -import matplotlib.pyplot as plt from matplotlib.backends.backend_pdf import PdfPages +import matplotlib.pyplot as plt +import lhapdf +import eko use("PDF") rc("font", **{"family": "sans-serif", "sans-serif": ["Helvetica"]}) @@ -33,8 +31,19 @@ pkg_path = pathlib.Path(__file__).absolute().parents[0] -def plot_pdf(log, pdf_name): - +def plot_pdf(log, pdf_name, q0): + """ + Plotting routine + + Parameters + ---------- + log: dict + log table + pdf_name: str + PDFs label + q0: float + initial scale + """ path = pkg_path / f"{pdf_name}.pdf" print(f"Writing pdf plots to {path}") @@ -43,22 +52,46 @@ def plot_pdf(log, pdf_name): fig = plt.figure(figsize=(15, 5)) plt.title(name) + # compute average and std + mean = vals.groupby(["x"], axis=0, as_index=False).mean() + std = vals.groupby(["x"], axis=0, as_index=False).std() + + # plot evoluted result + ax = mean.plot("x", "eko") + plt.fill_between( + std.x, mean.eko - 2 * std.eko, mean.eko + 2 * std.eko, alpha=0.2 + ) + # plot initial pdf + mean.plot("x", "inputpdf", ax=ax) + plt.fill_between( + std.x, + mean.inputpdf - 2 * std.inputpdf, + mean.inputpdf + 2 * std.inputpdf, + alpha=0.2, + ) - mean = vals.groupby(['x'], axis=0, as_index=False).mean() - std = vals.groupby(['x'], axis=0, as_index=False).std() - mean.plot('x', 'eko') - plt.fill_between(std.x, mean.eko - std.eko, mean.eko + std.eko, alpha=0.2) - - plt.xscale("log") - plt.ylabel(r"$\rm{ x%s(x)}$"%name, fontsize=11) - plt.xlabel("x") - plt.plot(np.geomspace(1e-7,1,200), np.zeros(200), "k--", alpha=0.7) - #plt.legend(f"{pdf_name} @ 1.5 GeV") + # plt.xscale("log") + quark_name = name + if "bar" in name: + quark_name = r"$\bar{%s}$" % name[0] + plt.ylabel(r"\rm{x %s(x)}" % quark_name, fontsize=11) + plt.xlabel(r"\rm{x}") + plt.xlim(1e-6, 1.0) + plt.ylim(-0.5, 2.5) + ax.legend( + [ + r"\rm{ %s\ @\ %s\ GeV\ }" + % (pdf_name.replace("_", r"\ "), np.round(np.sqrt(mean.Q2[0]), 2)), + r"\rm{ %s\ @\ %s\ GeV\ }" + % (pdf_name.replace("_", r"\ "), np.round(q0, 2)), + ] + ) + plt.plot(np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5) plt.tight_layout() - pp.savefig() plt.close(fig) + class Runner(BenchmarkRunner): """ EKO specialization of the banana runner. @@ -67,15 +100,30 @@ class Runner(BenchmarkRunner): banana_cfg = load_config(pkg_path) db_base_cls = db.Base rotate_to_evolution_basis = False - pdf_name="NNPDF31_nnlo_as_0118" - skip_pdfs=[5,-5,-6,6,22] + pdf_name = "NNPDF31_nnlo_as_0118" + skip_pdfs = [5, -5, -6, 6, 22] @staticmethod def load_ocards(session, ocard_updates): return operators.load(session, ocard_updates) - def run_external(self, theory, ocard, pdf): - pass + def run_external(self, theory, ocard, _pdf): + """Store the initial pdf and its uncertanty""" + xgrid = ocard["interpolation_xgrid"] + q0 = theory["Q0"] + ext = {} + pdfs = lhapdf.mkPDFs(self.pdf_name) + for rep, base_pdf in enumerate(pdfs): + tab = {} + for x in xgrid: + in_pdf = base_pdf.xfxQ(x, q0) + for pid, val in in_pdf.items(): + if pid not in tab: + tab[pid] = [] + tab[pid].append(val) + + ext[rep] = tab + return ext def run_me(self, theory, ocard, _pdf): """ @@ -122,8 +170,8 @@ def run_me(self, theory, ocard, _pdf): return out - def log(self, _theory, ocard, _pdf, me, _ext): - + def log(self, theory, ocard, _pdf, me, ext): + """Apply PDFs to eko and produce log tables""" log_tabs = {} xgrid = ocard["interpolation_xgrid"] # assume to have just one q2 in the grid @@ -131,7 +179,7 @@ def log(self, _theory, ocard, _pdf, me, _ext): rotate_to_evolution = None if self.rotate_to_evolution_basis: - rotate_to_evolution = br.rotate_flavor_to_evolution.copy() + rotate_to_evolution = eko.basis_rotation.rotate_flavor_to_evolution.copy() pdfs = lhapdf.mkPDFs(self.pdf_name) @@ -144,7 +192,7 @@ def log(self, _theory, ocard, _pdf, me, _ext): ) log_tab = dfdict.DFdict() - #ref_pdfs = ext["values"][q2] + ref_pdfs = ext[rep] res = pdf_grid[q2] my_pdfs = res["pdfs"] my_pdf_errs = res["errors"] @@ -158,15 +206,17 @@ def log(self, _theory, ocard, _pdf, me, _ext): tab["Q2"] = q2 tab["eko"] = xgrid * my_pdfs[key] tab["eko_error"] = xgrid * my_pdf_errs[key] - #tab[self.external] = r = ref_pdfs[key] - #tab["percent_error"] = (f - r) / r * 100 + tab["inputpdf"] = ref_pdfs[key] + # tab["percent_error"] = (f - r) / r * 100 log_tab[pdfname(key)] = pd.DataFrame(tab) log_tabs[rep] = log_tab # Plot - new_log = functools.reduce(lambda dfd1, dfd2: dfd1.merge(dfd2), log_tabs.values()) - plot_pdf(new_log, self.pdf_name) + new_log = functools.reduce( + lambda dfd1, dfd2: dfd1.merge(dfd2), log_tabs.values() + ) + plot_pdf(new_log, self.pdf_name, theory["Q0"]) return new_log @@ -186,9 +236,10 @@ def log(self, _theory, ocard, _pdf, me, _ext): "Q0": 1.65, } operator_updates = { - "Q2grid": [1.5], + "interpolation_xgrid": np.geomspace(0.0001, 1, 100), + "Q2grid": [1.50 ** 2], "backward_inversion": "exact", } - + # toyLH is not used in log backward_runner.run([theory_updates], [operator_updates], ["ToyLH"]) From a858d69e9169fb1122dd0254e8a8df85395e7fcf Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 6 Jul 2021 11:01:21 +0200 Subject: [PATCH 04/71] plot improvements --- backward_paper/evolve_backward.py | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 78026cede..563211fea 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -11,7 +11,7 @@ import numpy as np from banana import load_config -from banana.benchmark.runner import BenchmarkRunner +from banana.benchmark.runner import BenchmarkRunner, get_pdf from banana.data import dfdict from ekomark.data import operators, db @@ -70,14 +70,14 @@ def plot_pdf(log, pdf_name, q0): alpha=0.2, ) - # plt.xscale("log") + #plt.xscale("log") quark_name = name if "bar" in name: quark_name = r"$\bar{%s}$" % name[0] plt.ylabel(r"\rm{x %s(x)}" % quark_name, fontsize=11) plt.xlabel(r"\rm{x}") plt.xlim(1e-6, 1.0) - plt.ylim(-0.5, 2.5) + plt.ylim(-0.050, 0.05) ax.legend( [ r"\rm{ %s\ @\ %s\ GeV\ }" @@ -100,7 +100,7 @@ class Runner(BenchmarkRunner): banana_cfg = load_config(pkg_path) db_base_cls = db.Base rotate_to_evolution_basis = False - pdf_name = "NNPDF31_nnlo_as_0118" + pdf_name = "NNPDF40_nnlo_pch_as_0118" skip_pdfs = [5, -5, -6, 6, 22] @staticmethod @@ -112,6 +112,9 @@ def run_external(self, theory, ocard, _pdf): xgrid = ocard["interpolation_xgrid"] q0 = theory["Q0"] ext = {} + + # is the set installed? if not do it now + get_pdf(self.pdf_name) pdfs = lhapdf.mkPDFs(self.pdf_name) for rep, base_pdf in enumerate(pdfs): tab = {} @@ -224,8 +227,8 @@ def log(self, theory, ocard, _pdf, me, ext): backward_runner = Runner() theory_updates = { - "Qref": 91.2, - "alphas": 0.118000, + "Qref": 9.1187600e+01, + "alphas": 0.1180024, "mc": 1.51, "mb": 4.92, "mt": 172.5, @@ -234,11 +237,12 @@ def log(self, theory, ocard, _pdf, me, ext): "ktThr": 1.0, "PTO": 2, "Q0": 1.65, + "IC": 1, } operator_updates = { - "interpolation_xgrid": np.geomspace(0.0001, 1, 100), + "interpolation_xgrid": np.linspace(0.01, 1, 100), "Q2grid": [1.50 ** 2], - "backward_inversion": "exact", + "backward_inversion": "expanded", } # toyLH is not used in log From 0c369cf3cddc20ab06213f9ca46799bad051a48c Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 6 Jul 2021 15:48:11 +0200 Subject: [PATCH 05/71] Select correct 4.0 pdfs, add pm basis plots --- backward_paper/evolve_backward.py | 119 +++++++++++------------------- backward_paper/plots.py | 80 ++++++++++++++++++++ 2 files changed, 123 insertions(+), 76 deletions(-) create mode 100644 backward_paper/plots.py diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 563211fea..965fee7c4 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -7,6 +7,7 @@ import pathlib import os import sys +import copy import pandas as pd import numpy as np @@ -17,91 +18,51 @@ from ekomark.data import operators, db from ekomark import pdfname -from matplotlib import use, rc -from matplotlib.backends.backend_pdf import PdfPages -import matplotlib.pyplot as plt +from plots import plot_pdf import lhapdf import eko -use("PDF") -rc("font", **{"family": "sans-serif", "sans-serif": ["Helvetica"]}) -rc("text", usetex=True) - pkg_path = pathlib.Path(__file__).absolute().parents[0] -def plot_pdf(log, pdf_name, q0): - """ - Plotting routine - - Parameters - ---------- - log: dict - log table - pdf_name: str - PDFs label - q0: float - initial scale - """ - path = pkg_path / f"{pdf_name}.pdf" - print(f"Writing pdf plots to {path}") - - with PdfPages(path) as pp: - for name, vals in log.items(): - - fig = plt.figure(figsize=(15, 5)) - plt.title(name) - # compute average and std - mean = vals.groupby(["x"], axis=0, as_index=False).mean() - std = vals.groupby(["x"], axis=0, as_index=False).std() - - # plot evoluted result - ax = mean.plot("x", "eko") - plt.fill_between( - std.x, mean.eko - 2 * std.eko, mean.eko + 2 * std.eko, alpha=0.2 - ) - # plot initial pdf - mean.plot("x", "inputpdf", ax=ax) - plt.fill_between( - std.x, - mean.inputpdf - 2 * std.inputpdf, - mean.inputpdf + 2 * std.inputpdf, - alpha=0.2, - ) - - #plt.xscale("log") - quark_name = name - if "bar" in name: - quark_name = r"$\bar{%s}$" % name[0] - plt.ylabel(r"\rm{x %s(x)}" % quark_name, fontsize=11) - plt.xlabel(r"\rm{x}") - plt.xlim(1e-6, 1.0) - plt.ylim(-0.050, 0.05) - ax.legend( - [ - r"\rm{ %s\ @\ %s\ GeV\ }" - % (pdf_name.replace("_", r"\ "), np.round(np.sqrt(mean.Q2[0]), 2)), - r"\rm{ %s\ @\ %s\ GeV\ }" - % (pdf_name.replace("_", r"\ "), np.round(q0, 2)), - ] - ) - plt.plot(np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5) - plt.tight_layout() - pp.savefig() - plt.close(fig) +def rotate_to_pm_basis(log): + """Rotate to plus minus basis""" + # TODO: this can be improved + rot_log = {} + if "g" in log: + rot_log["g"] = log["g"] + for pid in eko.evolution_operator.flavors.quark_names: + if pid not in log: + continue + quark = log[pid] + qbar = log[f"{pid}bar"].copy() + rot_log[r"${%s}^{+}$" % (pid)] = copy.deepcopy(log[pid]) + rot_log[r"${%s}^{-}$" % (pid)] = copy.deepcopy(log[pid]) + rot_log[r"${%s}^{+}$" % (pid)].eko = (quark + qbar).eko + rot_log[r"${%s}^{-}$" % (pid)].eko = (quark - qbar).eko + rot_log[r"${%s}^{+}$" % (pid)].inputpdf = (quark + qbar).inputpdf + rot_log[r"${%s}^{-}$" % (pid)].inputpdf = (quark - qbar).inputpdf + return rot_log class Runner(BenchmarkRunner): """ EKO specialization of the banana runner. + + Prameters + --------- + pdf_name: str + PDF name """ - banana_cfg = load_config(pkg_path) - db_base_cls = db.Base - rotate_to_evolution_basis = False - pdf_name = "NNPDF40_nnlo_pch_as_0118" - skip_pdfs = [5, -5, -6, 6, 22] + def __init__(self, pdf_name): + super().__init__() + self.banana_cfg = load_config(pkg_path) + self.db_base_cls = db.Base + self.rotate_to_evolution_basis = False + self.pdf_name = pdf_name + self.skip_pdfs = [21, -1, 1, -2, 2, -3, 3, 5, -5, -6, 6, 22] @staticmethod def load_ocards(session, ocard_updates): @@ -219,15 +180,14 @@ def log(self, theory, ocard, _pdf, me, ext): new_log = functools.reduce( lambda dfd1, dfd2: dfd1.merge(dfd2), log_tabs.values() ) - plot_pdf(new_log, self.pdf_name, theory["Q0"]) + plot_pdf(rotate_to_pm_basis(new_log), self.pdf_name, theory["Q0"], cl=1) return new_log if __name__ == "__main__": - backward_runner = Runner() theory_updates = { - "Qref": 9.1187600e+01, + "Qref": 9.1187600e01, "alphas": 0.1180024, "mc": 1.51, "mb": 4.92, @@ -245,5 +205,12 @@ def log(self, theory, ocard, _pdf, me, ext): "backward_inversion": "expanded", } - # toyLH is not used in log - backward_runner.run([theory_updates], [operator_updates], ["ToyLH"]) + pdf_names = [ + "210629-n3fit-001", # NNLO, fitted charm + "210629-theory-003", # NNLO, perturbative charm + "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c + ] + + for name in pdf_names: + backward_runner = Runner(name) + backward_runner.run([theory_updates], [operator_updates], [name]) diff --git a/backward_paper/plots.py b/backward_paper/plots.py new file mode 100644 index 000000000..a9b9dc296 --- /dev/null +++ b/backward_paper/plots.py @@ -0,0 +1,80 @@ +# -*- coding: utf-8 -*- +""" +Plotting options +""" +import pathlib +import numpy as np + +from matplotlib import use, rc +from matplotlib.backends.backend_pdf import PdfPages +import matplotlib.pyplot as plt + + +use("PDF") +rc("font", **{"family": "sans-serif", "sans-serif": ["Helvetica"]}) +rc("text", usetex=True) + +pkg_path = pathlib.Path(__file__).absolute().parents[0] + + +def plot_pdf(log, pdf_name, q0, cl=1): + """ + Plotting routine + + Parameters + ---------- + log: dict + log table + pdf_name: str + PDFs label + q0: float + initial scale + cl: int + confidence level interval ( in units of sigma ) + """ + path = pkg_path / f"{pdf_name}.pdf" + print(f"Writing pdf plots to {path}") + + with PdfPages(path) as pp: + for name, vals in log.items(): + + fig = plt.figure(figsize=(15, 5)) + plt.title(name) + # compute average and std + mean = vals.groupby(["x"], axis=0, as_index=False).mean() + std = vals.groupby(["x"], axis=0, as_index=False).std() + + # plot evoluted result + ax = mean.plot("x", "eko") + plt.fill_between( + std.x, mean.eko - cl * std.eko, mean.eko + cl * std.eko, alpha=0.2 + ) + # plot initial pdf + mean.plot("x", "inputpdf", ax=ax) + plt.fill_between( + std.x, + mean.inputpdf - cl * std.inputpdf, + mean.inputpdf + cl * std.inputpdf, + alpha=0.2, + ) + + plt.xscale("log") + quark_name = name + if "bar" in name: + quark_name = r"$\bar{%s}$" % name[0] + plt.ylabel(r"\rm{x %s(x)}" % quark_name, fontsize=11) + plt.xlabel(r"\rm{x}") + plt.xlim(1e-2, 1.0) + plt.ylim(-0.04, 0.04) + ax.legend( + [ + r"\rm{ %s\ @\ %s\ GeV\ }" + % (pdf_name.replace("_", r"\ "), np.round(np.sqrt(mean.Q2[0]), 2)), + r"\rm{ %s\ @\ %s\ GeV\ }" + % (pdf_name.replace("_", r"\ "), np.round(q0, 2)), + ] + ) + plt.plot(np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5) + plt.tight_layout() + pp.savefig() + plt.close(fig) From 85d5748dcf572b456d00f9895f2d05e69a2ec15c Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 8 Jul 2021 11:44:23 +0200 Subject: [PATCH 06/71] Make use of Ekomark runner and add comparison below above thr --- backward_paper/banana.yaml | 2 +- backward_paper/evolve_backward.py | 248 +++++++------------------ backward_paper/plots.py | 58 +++--- backward_paper/runner.py | 139 ++++++++++++++ benchmarks/ekomark/benchmark/runner.py | 16 +- 5 files changed, 239 insertions(+), 224 deletions(-) create mode 100644 backward_paper/runner.py diff --git a/backward_paper/banana.yaml b/backward_paper/banana.yaml index 13dfa8952..e2903b40d 100644 --- a/backward_paper/banana.yaml +++ b/backward_paper/banana.yaml @@ -1,4 +1,4 @@ -database_path: benchmark.db +database_path: database.db input_tables: - theories - operators diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 965fee7c4..a7c622f9c 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -2,191 +2,20 @@ """ This script compute an EKO to evolve a PDF set under the charm thrshold replica by replica """ -import functools -import logging -import pathlib -import os -import sys -import copy -import pandas as pd import numpy as np -from banana import load_config -from banana.benchmark.runner import BenchmarkRunner, get_pdf -from banana.data import dfdict +from runner import EkoRunner -from ekomark.data import operators, db -from ekomark import pdfname -from plots import plot_pdf - -import lhapdf -import eko - -pkg_path = pathlib.Path(__file__).absolute().parents[0] - - -def rotate_to_pm_basis(log): - """Rotate to plus minus basis""" - # TODO: this can be improved - rot_log = {} - if "g" in log: - rot_log["g"] = log["g"] - for pid in eko.evolution_operator.flavors.quark_names: - if pid not in log: - continue - quark = log[pid] - qbar = log[f"{pid}bar"].copy() - rot_log[r"${%s}^{+}$" % (pid)] = copy.deepcopy(log[pid]) - rot_log[r"${%s}^{-}$" % (pid)] = copy.deepcopy(log[pid]) - rot_log[r"${%s}^{+}$" % (pid)].eko = (quark + qbar).eko - rot_log[r"${%s}^{-}$" % (pid)].eko = (quark - qbar).eko - rot_log[r"${%s}^{+}$" % (pid)].inputpdf = (quark + qbar).inputpdf - rot_log[r"${%s}^{-}$" % (pid)].inputpdf = (quark - qbar).inputpdf - return rot_log - - -class Runner(BenchmarkRunner): +class BackwardRunner(EkoRunner): """ - EKO specialization of the banana runner. - - Prameters - --------- - pdf_name: str - PDF name + This class evolve a pdf below the charm thrshold and + compare it with the initial pdf replica by replica. """ - def __init__(self, pdf_name): - super().__init__() - self.banana_cfg = load_config(pkg_path) - self.db_base_cls = db.Base - self.rotate_to_evolution_basis = False - self.pdf_name = pdf_name - self.skip_pdfs = [21, -1, 1, -2, 2, -3, 3, 5, -5, -6, 6, 22] - - @staticmethod - def load_ocards(session, ocard_updates): - return operators.load(session, ocard_updates) - - def run_external(self, theory, ocard, _pdf): - """Store the initial pdf and its uncertanty""" - xgrid = ocard["interpolation_xgrid"] - q0 = theory["Q0"] - ext = {} - - # is the set installed? if not do it now - get_pdf(self.pdf_name) - pdfs = lhapdf.mkPDFs(self.pdf_name) - for rep, base_pdf in enumerate(pdfs): - tab = {} - for x in xgrid: - in_pdf = base_pdf.xfxQ(x, q0) - for pid, val in in_pdf.items(): - if pid not in tab: - tab[pid] = [] - tab[pid].append(val) - - ext[rep] = tab - return ext - - def run_me(self, theory, ocard, _pdf): - """ - Run eko - - Parameters - ---------- - theory : dict - theory card - ocard : dict - operator card - - Returns - ------- - out : dict - DGLAP result - """ - - # activate logging - logStdout = logging.StreamHandler(sys.stdout) - logStdout.setLevel(logging.INFO) - logStdout.setFormatter(logging.Formatter("%(message)s")) - logging.getLogger("eko").handlers = [] - logging.getLogger("eko").addHandler(logStdout) - logging.getLogger("eko").setLevel(logging.INFO) - - ops_id = f"o{ocard['hash'][:6]}_t{theory['hash'][:6]}" - path = f"{self.banana_cfg['database_path'].parents[0]}/{ops_id}.yaml" - rerun = True - if os.path.exists(path): - rerun = False - ask = input("Use cached output? [Y/n]") - if ask.lower() in ["n", "no"]: - rerun = True - - if rerun: - out = eko.run_dglap(theory, ocard) - print(f"Writing operator to {path}") - out.dump_yaml_to_file(path) - else: - print(f"Using cached eko data: {os.path.relpath(path,os.getcwd())}") - with open(path) as o: - out = eko.output.Output.load_yaml(o) - - return out - - def log(self, theory, ocard, _pdf, me, ext): - """Apply PDFs to eko and produce log tables""" - log_tabs = {} - xgrid = ocard["interpolation_xgrid"] - # assume to have just one q2 in the grid - q2 = ocard["Q2grid"][0] - - rotate_to_evolution = None - if self.rotate_to_evolution_basis: - rotate_to_evolution = eko.basis_rotation.rotate_flavor_to_evolution.copy() - - pdfs = lhapdf.mkPDFs(self.pdf_name) - - # Loop over pdfs replicas - for rep, pdf in enumerate(pdfs): - pdf_grid = me.apply_pdf_flavor( - pdf, - xgrid, - flavor_rotation=rotate_to_evolution, - ) - - log_tab = dfdict.DFdict() - ref_pdfs = ext[rep] - res = pdf_grid[q2] - my_pdfs = res["pdfs"] - my_pdf_errs = res["errors"] + external = "inputpdf" - for key in my_pdfs: - if key in self.skip_pdfs: - continue - # build table - tab = {} - tab["x"] = xgrid - tab["Q2"] = q2 - tab["eko"] = xgrid * my_pdfs[key] - tab["eko_error"] = xgrid * my_pdf_errs[key] - tab["inputpdf"] = ref_pdfs[key] - # tab["percent_error"] = (f - r) / r * 100 - - log_tab[pdfname(key)] = pd.DataFrame(tab) - log_tabs[rep] = log_tab - - # Plot - new_log = functools.reduce( - lambda dfd1, dfd2: dfd1.merge(dfd2), log_tabs.values() - ) - plot_pdf(rotate_to_pm_basis(new_log), self.pdf_name, theory["Q0"], cl=1) - return new_log - - -if __name__ == "__main__": - - theory_updates = { + base_theory = { "Qref": 9.1187600e01, "alphas": 0.1180024, "mc": 1.51, @@ -196,21 +25,68 @@ def log(self, theory, ocard, _pdf, me, ext): "kbThr": 1.0, "ktThr": 1.0, "PTO": 2, - "Q0": 1.65, "IC": 1, } - operator_updates = { - "interpolation_xgrid": np.linspace(0.01, 1, 100), - "Q2grid": [1.50 ** 2], + base_operator = { + # "interpolation_xgrid": np.linspace(0.01, 1, 100), + # "interpolation_xgrid": np.geomspace(0.0001, 1, 100), + # "interpolation_xgrid": eko.interpolation.make_grid(30,20).tolist(), "backward_inversion": "expanded", } + def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5): + """ + Base backward evolution + + Parameters + ---------- + pdf_name: str + PDF name + q_high: float + initial scale + q_low: float + final scale + """ + self.fig_name = pdf_name + operator_updates = self.base_operator + operator_updates["Q2grid"] = [q_low ** 2] + theory_updates = self.base_theory + theory_updates["Q0"] = q_high + + self.run([theory_updates], [operator_updates], [pdf_name]) + + def evolve_above_below_thr(self, pdf_name, heavy_quark="c", epsilon=0.01): + """ + Comapare above and below the heavy quark threshold + + Parameters + ---------- + pdf_name: str + PDF name + heavy_quark: str + heavy quark name + epsilon: float + distance from threshold + """ + self.fig_name = f"compare_thr_{pdf_name}" + operator_updates = self.base_operator + thr_scale = ( + self.base_theory[f"m{heavy_quark}"] * self.base_theory[f"k{heavy_quark}Thr"] + ) + operator_updates["Q2grid"] = np.power( + [thr_scale + epsilon, thr_scale - epsilon], 2 + ) + self.run([self.base_theory], [operator_updates], [pdf_name]) + + +if __name__ == "__main__": + + myrunner = BackwardRunner() pdf_names = [ "210629-n3fit-001", # NNLO, fitted charm - "210629-theory-003", # NNLO, perturbative charm - "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c + # "210629-theory-003", # NNLO, perturbative charm + # "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c ] - for name in pdf_names: - backward_runner = Runner(name) - backward_runner.run([theory_updates], [operator_updates], [name]) + myrunner.evolve_backward(name) + myrunner.evolve_above_below_thr(name) diff --git a/backward_paper/plots.py b/backward_paper/plots.py index a9b9dc296..1c4e5dde4 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -17,7 +17,7 @@ pkg_path = pathlib.Path(__file__).absolute().parents[0] -def plot_pdf(log, pdf_name, q0, cl=1): +def plot_pdf(log, fig_name, cl=1, logscale=True): """ Plotting routine @@ -25,14 +25,14 @@ def plot_pdf(log, pdf_name, q0, cl=1): ---------- log: dict log table - pdf_name: str - PDFs label - q0: float - initial scale + fig_name: str + Figure name cl: int confidence level interval ( in units of sigma ) + logscale: bool + plot with x axis in log scale """ - path = pkg_path / f"{pdf_name}.pdf" + path = pkg_path / f"{fig_name}.pdf" print(f"Writing pdf plots to {path}") with PdfPages(path) as pp: @@ -44,36 +44,34 @@ def plot_pdf(log, pdf_name, q0, cl=1): mean = vals.groupby(["x"], axis=0, as_index=False).mean() std = vals.groupby(["x"], axis=0, as_index=False).std() - # plot evoluted result - ax = mean.plot("x", "eko") - plt.fill_between( - std.x, mean.eko - cl * std.eko, mean.eko + cl * std.eko, alpha=0.2 - ) - # plot initial pdf - mean.plot("x", "inputpdf", ax=ax) - plt.fill_between( - std.x, - mean.inputpdf - cl * std.inputpdf, - mean.inputpdf + cl * std.inputpdf, - alpha=0.2, - ) + # plot pdfs + labels = [] + for idx, (column_name, column_data) in enumerate(mean.items()): + if "x" in column_name or "error" in column_name: + continue + if idx == 1: + ax = mean.plot("x", f"{column_name}") + else: + mean.plot("x", f"{column_name}", ax=ax) - plt.xscale("log") + plt.fill_between( + mean.x, + column_data - cl * std[column_name], + column_data + cl * std[column_name], + alpha=0.2, + ) + labels.append(r"\rm{ %s\ GeV\ }" % (column_name.replace("_", r"\ "))) + + if logscale: + plt.xscale("log") quark_name = name if "bar" in name: quark_name = r"$\bar{%s}$" % name[0] plt.ylabel(r"\rm{x %s(x)}" % quark_name, fontsize=11) plt.xlabel(r"\rm{x}") - plt.xlim(1e-2, 1.0) - plt.ylim(-0.04, 0.04) - ax.legend( - [ - r"\rm{ %s\ @\ %s\ GeV\ }" - % (pdf_name.replace("_", r"\ "), np.round(np.sqrt(mean.Q2[0]), 2)), - r"\rm{ %s\ @\ %s\ GeV\ }" - % (pdf_name.replace("_", r"\ "), np.round(q0, 2)), - ] - ) + plt.xlim(std.x.min(), 1.0) + # plt.ylim(-0.04, 0.04) + ax.legend(labels) plt.plot(np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5) plt.tight_layout() pp.savefig() diff --git a/backward_paper/runner.py b/backward_paper/runner.py new file mode 100644 index 000000000..1cac3944c --- /dev/null +++ b/backward_paper/runner.py @@ -0,0 +1,139 @@ +# -*- coding: utf-8 -*- +""" +This script contains a specialization of the Ekomark runner +""" +import functools +import pathlib +import copy +import pandas as pd +import numpy as np + +from banana import load_config +from banana.data import dfdict + +from ekomark.benchmark.runner import Runner +from ekomark import pdfname + +from plots import plot_pdf + +import lhapdf +import eko + +pkg_path = pathlib.Path(__file__).absolute().parents[0] + + +def rotate_to_pm_basis(log): + """Rotate to plus minus basis""" + # TODO: this can be improved + rot_log = {} + if "g" in log: + rot_log["g"] = log["g"] + for pid in eko.evolution_operator.flavors.quark_names: + if pid not in log: + continue + quark = log[pid] + qbar = log[f"{pid}bar"].copy() + rot_log[r"${%s}^{+}$" % (pid)] = copy.deepcopy(log[pid]) + rot_log[r"${%s}^{-}$" % (pid)] = copy.deepcopy(log[pid]) + + for column_name, column_data in quark.items(): + if column_name == "x": + continue + rot_log[r"${%s}^{+}$" % (pid)][column_name] = ( + column_data + qbar[column_name] + ) + rot_log[r"${%s}^{-}$" % (pid)][column_name] = ( + column_data - qbar[column_name] + ) + return rot_log + + +class EkoRunner(Runner): + """ + Specialization of the Ekomark runner. + """ + + def __init__(self): + super().__init__() + self.banana_cfg = load_config(pkg_path) + self.rotate_to_evolution_basis = False + self.skip_pdfs = [21, -1, 1, -2, 2, -3, 3, 5, -5, -6, 6, 22] + self.sandbox = True + self.fig_name = None + + def run_external(self, theory, ocard, pdf): + + if self.external == "inputpdf": + # Compare with the initial pdf + + xgrid = ocard["interpolation_xgrid"] + q0 = theory["Q0"] + ext = {} + pdfs = lhapdf.mkPDFs(pdf.set().name) + for rep, base_pdf in enumerate(pdfs): + tab = {} + for x in xgrid: + in_pdf = base_pdf.xfxQ(x, q0) + for pid, val in in_pdf.items(): + if pid not in tab: + tab[pid] = [] + tab[pid].append(val) + + ext[rep] = tab + return ext + + def log(self, theory, ocard, _pdf, me, ext): + """Apply PDFs to eko and produce log tables""" + log_tabs = {} + xgrid = ocard["interpolation_xgrid"] + q2s = ocard["Q2grid"] + + rotate_to_evolution = None + if self.rotate_to_evolution_basis: + rotate_to_evolution = eko.basis_rotation.rotate_flavor_to_evolution.copy() + + pdf_name = _pdf.set().name + pdfs = lhapdf.mkPDFs(pdf_name) + + # build table + tab = {} + tab["x"] = xgrid + + # Loop over pdfs replicas + for rep, pdf in enumerate(pdfs): + pdf_grid = me.apply_pdf_flavor( + pdf, + xgrid, + flavor_rotation=rotate_to_evolution, + ) + + log_tab = dfdict.DFdict() + ref_pdfs = ext[rep] + + # Loop over pdf ids + for key in ref_pdfs: + if key in self.skip_pdfs: + continue + + if self.external == "inputpdf": + tab[f'{pdf_name}_@_{theory["Q0"]}'] = ref_pdfs[key] + + # Loop over q2 grid + for q2 in q2s: + res = pdf_grid[q2] + my_pdfs = res["pdfs"] + my_pdf_errs = res["errors"] + tab[f"EKO_@_{np.round(np.sqrt(q2), 2)}"] = xgrid * my_pdfs[key] + tab[f"EKO_error_@_{np.round(np.sqrt(q2), 2)}"] = ( + xgrid * my_pdf_errs[key] + ) + + log_tab[pdfname(key)] = pd.DataFrame(tab) + log_tabs[rep] = log_tab + + # Plot + new_log = functools.reduce( + lambda dfd1, dfd2: dfd1.merge(dfd2), log_tabs.values() + ) + plot_pdf(rotate_to_pm_basis(new_log), self.fig_name, cl=1, logscale=True) + return new_log diff --git a/benchmarks/ekomark/benchmark/runner.py b/benchmarks/ekomark/benchmark/runner.py index d97b32957..318c7d7b5 100644 --- a/benchmarks/ekomark/benchmark/runner.py +++ b/benchmarks/ekomark/benchmark/runner.py @@ -23,12 +23,14 @@ class Runner(BenchmarkRunner): """ EKO specialization of the banana runner. """ - - banana_cfg = banana_cfg db_base_cls = db.Base - rotate_to_evolution_basis = False - sandbox = False - plot_operator = False + + def __init__(self): + super().__init__() + self.banana_cfg = banana_cfg + self.rotate_to_evolution_basis = False + self.sandbox = False + self.plot_operator = False @staticmethod def load_ocards(session, ocard_updates): @@ -70,7 +72,7 @@ def run_me(self, theory, ocard, _pdf): if self.sandbox: rerun = True ops_id = f"o{ocard['hash'][:6]}_t{theory['hash'][:6]}" - path = f"{banana_cfg['database_path'].parents[0]}/{ops_id}.yaml" + path = f"{self.banana_cfg['database_path'].parents[0]}/{ops_id}.yaml" if os.path.exists(path): rerun = False @@ -94,7 +96,7 @@ def run_me(self, theory, ocard, _pdf): ) output_path = ( - f"{banana_cfg['database_path'].parents[0]}/{self.external}_bench" + f"{self.banana_cfg['database_path'].parents[0]}/{self.external}_bench" ) if not os.path.exists(output_path): os.makedirs(output_path) From f04b3afa13378e9d1a4b4a376d223d2271eaf29e Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 8 Jul 2021 14:38:16 +0200 Subject: [PATCH 07/71] Plot log scale and linear, add IB check --- backward_paper/evolve_backward.py | 22 +++++++++-- backward_paper/plots.py | 61 ++++++++++++++++--------------- backward_paper/runner.py | 6 +-- 3 files changed, 52 insertions(+), 37 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index a7c622f9c..3724076b5 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -6,6 +6,8 @@ from runner import EkoRunner +pid_dict = {"c": 4, "b": 5, "t": 6} + class BackwardRunner(EkoRunner): """ @@ -43,9 +45,9 @@ def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5): pdf_name: str PDF name q_high: float - initial scale + initial Q scale q_low: float - final scale + final Q scale """ self.fig_name = pdf_name operator_updates = self.base_operator @@ -55,7 +57,9 @@ def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5): self.run([theory_updates], [operator_updates], [pdf_name]) - def evolve_above_below_thr(self, pdf_name, heavy_quark="c", epsilon=0.01): + def evolve_above_below_thr( + self, pdf_name, q_high=1.65, heavy_quark="c", epsilon=0.01 + ): """ Comapare above and below the heavy quark threshold @@ -63,12 +67,16 @@ def evolve_above_below_thr(self, pdf_name, heavy_quark="c", epsilon=0.01): ---------- pdf_name: str PDF name + q_high: float + initial Q scale heavy_quark: str heavy quark name epsilon: float distance from threshold """ - self.fig_name = f"compare_thr_{pdf_name}" + self.fig_name = f"compare_thr_{heavy_quark}_{pdf_name}" + self.plot_pdfs = [-pid_dict[heavy_quark], pid_dict[heavy_quark]] + operator_updates = self.base_operator thr_scale = ( self.base_theory[f"m{heavy_quark}"] * self.base_theory[f"k{heavy_quark}Thr"] @@ -76,6 +84,8 @@ def evolve_above_below_thr(self, pdf_name, heavy_quark="c", epsilon=0.01): operator_updates["Q2grid"] = np.power( [thr_scale + epsilon, thr_scale - epsilon], 2 ) + theory_updates = self.base_theory + theory_updates["Q0"] = q_high self.run([self.base_theory], [operator_updates], [pdf_name]) @@ -90,3 +100,7 @@ def evolve_above_below_thr(self, pdf_name, heavy_quark="c", epsilon=0.01): for name in pdf_names: myrunner.evolve_backward(name) myrunner.evolve_above_below_thr(name) + + # Test perturbarive B + pdf_name = "210629-n3fit-001" + myrunner.evolve_above_below_thr(pdf_name, q_high=5, heavy_quark="b") diff --git a/backward_paper/plots.py b/backward_paper/plots.py index 1c4e5dde4..0f47a3fae 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -17,7 +17,7 @@ pkg_path = pathlib.Path(__file__).absolute().parents[0] -def plot_pdf(log, fig_name, cl=1, logscale=True): +def plot_pdf(log, fig_name, cl=1): """ Plotting routine @@ -29,8 +29,6 @@ def plot_pdf(log, fig_name, cl=1, logscale=True): Figure name cl: int confidence level interval ( in units of sigma ) - logscale: bool - plot with x axis in log scale """ path = pkg_path / f"{fig_name}.pdf" print(f"Writing pdf plots to {path}") @@ -38,41 +36,44 @@ def plot_pdf(log, fig_name, cl=1, logscale=True): with PdfPages(path) as pp: for name, vals in log.items(): - fig = plt.figure(figsize=(15, 5)) - plt.title(name) + fig, axs = plt.subplots(1, 2, figsize=(15, 5)) # compute average and std mean = vals.groupby(["x"], axis=0, as_index=False).mean() std = vals.groupby(["x"], axis=0, as_index=False).std() # plot pdfs - labels = [] - for idx, (column_name, column_data) in enumerate(mean.items()): - if "x" in column_name or "error" in column_name: - continue - if idx == 1: - ax = mean.plot("x", f"{column_name}") - else: + for ax in axs: + labels = [] + y_min = 1.0 + for column_name, column_data in mean.items(): + if "x" in column_name or "error" in column_name: + continue mean.plot("x", f"{column_name}", ax=ax) - plt.fill_between( - mean.x, - column_data - cl * std[column_name], - column_data + cl * std[column_name], - alpha=0.2, - ) - labels.append(r"\rm{ %s\ GeV\ }" % (column_name.replace("_", r"\ "))) + ax.fill_between( + mean.x, + column_data - cl * std[column_name], + column_data + cl * std[column_name], + alpha=0.2, + ) + labels.append( + r"\rm{ %s\ GeV\ }" % (column_name.replace("_", r"\ ")) + ) - if logscale: - plt.xscale("log") - quark_name = name - if "bar" in name: - quark_name = r"$\bar{%s}$" % name[0] - plt.ylabel(r"\rm{x %s(x)}" % quark_name, fontsize=11) - plt.xlabel(r"\rm{x}") - plt.xlim(std.x.min(), 1.0) - # plt.ylim(-0.04, 0.04) - ax.legend(labels) - plt.plot(np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5) + if np.abs(column_data.min()) < np.abs(y_min): + y_min = np.abs(column_data.min()) + + quark_name = name + if "bar" in name: + quark_name = r"$\bar{%s}$" % name[0] + ax.set_xlabel(r"\rm{x}") + ax.set_xlim(mean.x.min(), 1.0) + ax.legend(labels) + ax.plot(np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5) + + axs[1].set_yscale("symlog", linthresh=1e-7 if y_min < 1e-7 else y_min) + axs[0].set_xscale("log") + axs[0].set_ylabel(r"\rm{x %s(x)}" % quark_name, fontsize=11) plt.tight_layout() pp.savefig() plt.close(fig) diff --git a/backward_paper/runner.py b/backward_paper/runner.py index 1cac3944c..81dd28be8 100644 --- a/backward_paper/runner.py +++ b/backward_paper/runner.py @@ -57,7 +57,7 @@ def __init__(self): super().__init__() self.banana_cfg = load_config(pkg_path) self.rotate_to_evolution_basis = False - self.skip_pdfs = [21, -1, 1, -2, 2, -3, 3, 5, -5, -6, 6, 22] + self.plot_pdfs = [4, -4] self.sandbox = True self.fig_name = None @@ -112,7 +112,7 @@ def log(self, theory, ocard, _pdf, me, ext): # Loop over pdf ids for key in ref_pdfs: - if key in self.skip_pdfs: + if key not in self.plot_pdfs: continue if self.external == "inputpdf": @@ -135,5 +135,5 @@ def log(self, theory, ocard, _pdf, me, ext): new_log = functools.reduce( lambda dfd1, dfd2: dfd1.merge(dfd2), log_tabs.values() ) - plot_pdf(rotate_to_pm_basis(new_log), self.fig_name, cl=1, logscale=True) + plot_pdf(rotate_to_pm_basis(new_log), self.fig_name, cl=1) return new_log From 3ad1224773521c73a252e62430d2c5a09a079b6b Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 8 Jul 2021 17:47:53 +0200 Subject: [PATCH 08/71] Init back and forth check --- backward_paper/evolve_backward.py | 30 +++++++----- backward_paper/plots.py | 16 +++++-- backward_paper/runner.py | 80 +++++++++++++++++++++++-------- 3 files changed, 89 insertions(+), 37 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 3724076b5..72d753a01 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -4,12 +4,12 @@ """ import numpy as np -from runner import EkoRunner +from runner import BackwardPaperRunner pid_dict = {"c": 4, "b": 5, "t": 6} -class BackwardRunner(EkoRunner): +class BackwardRunner(BackwardPaperRunner): """ This class evolve a pdf below the charm thrshold and compare it with the initial pdf replica by replica. @@ -32,11 +32,11 @@ class BackwardRunner(EkoRunner): base_operator = { # "interpolation_xgrid": np.linspace(0.01, 1, 100), # "interpolation_xgrid": np.geomspace(0.0001, 1, 100), - # "interpolation_xgrid": eko.interpolation.make_grid(30,20).tolist(), + #"interpolation_xgrid": eko.interpolation.make_grid(3,2).tolist(), "backward_inversion": "expanded", } - def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5): + def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5, return_to_Q0=False): """ Base backward evolution @@ -48,11 +48,14 @@ def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5): initial Q scale q_low: float final Q scale + return_to_Q0: bool + if True compute also the EKO back to test stability """ self.fig_name = pdf_name - operator_updates = self.base_operator + self.return_to_Q0 = return_to_Q0 + operator_updates = self.base_operator.copy() operator_updates["Q2grid"] = [q_low ** 2] - theory_updates = self.base_theory + theory_updates = self.base_theory.copy() theory_updates["Q0"] = q_high self.run([theory_updates], [operator_updates], [pdf_name]) @@ -77,21 +80,23 @@ def evolve_above_below_thr( self.fig_name = f"compare_thr_{heavy_quark}_{pdf_name}" self.plot_pdfs = [-pid_dict[heavy_quark], pid_dict[heavy_quark]] - operator_updates = self.base_operator + operator_updates = self.base_operator.copy() thr_scale = ( self.base_theory[f"m{heavy_quark}"] * self.base_theory[f"k{heavy_quark}Thr"] ) operator_updates["Q2grid"] = np.power( [thr_scale + epsilon, thr_scale - epsilon], 2 ) - theory_updates = self.base_theory + theory_updates = self.base_theory.copy() theory_updates["Q0"] = q_high - self.run([self.base_theory], [operator_updates], [pdf_name]) + self.run([theory_updates], [operator_updates], [pdf_name]) if __name__ == "__main__": myrunner = BackwardRunner() + + # Evolve below c threshold pdf_names = [ "210629-n3fit-001", # NNLO, fitted charm # "210629-theory-003", # NNLO, perturbative charm @@ -101,6 +106,9 @@ def evolve_above_below_thr( myrunner.evolve_backward(name) myrunner.evolve_above_below_thr(name) - # Test perturbarive B + # # Test perturbarive B pdf_name = "210629-n3fit-001" - myrunner.evolve_above_below_thr(pdf_name, q_high=5, heavy_quark="b") + # myrunner.evolve_above_below_thr(pdf_name, q_high=5, heavy_quark="b") + + # Test EKO back and forth + myrunner.evolve_backward(pdf_name, q_high=1.65, q_low=1.52, return_to_Q0=True) diff --git a/backward_paper/plots.py b/backward_paper/plots.py index 0f47a3fae..b0da1a848 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -17,6 +17,15 @@ pkg_path = pathlib.Path(__file__).absolute().parents[0] +def quark_latex_name(name): + quark_name = name + if "bar" in name: + quark_name = r"$\bar{%s}$" % name[0] + quark_name = quark_name.replace("plus", "+") + quark_name = quark_name.replace("minus", "-") + return quark_name + + def plot_pdf(log, fig_name, cl=1): """ Plotting routine @@ -46,7 +55,7 @@ def plot_pdf(log, fig_name, cl=1): labels = [] y_min = 1.0 for column_name, column_data in mean.items(): - if "x" in column_name or "error" in column_name: + if "x" in column_name: continue mean.plot("x", f"{column_name}", ax=ax) @@ -63,9 +72,6 @@ def plot_pdf(log, fig_name, cl=1): if np.abs(column_data.min()) < np.abs(y_min): y_min = np.abs(column_data.min()) - quark_name = name - if "bar" in name: - quark_name = r"$\bar{%s}$" % name[0] ax.set_xlabel(r"\rm{x}") ax.set_xlim(mean.x.min(), 1.0) ax.legend(labels) @@ -73,7 +79,7 @@ def plot_pdf(log, fig_name, cl=1): axs[1].set_yscale("symlog", linthresh=1e-7 if y_min < 1e-7 else y_min) axs[0].set_xscale("log") - axs[0].set_ylabel(r"\rm{x %s(x)}" % quark_name, fontsize=11) + axs[0].set_ylabel(r"\rm{x %s(x)}" % quark_latex_name(name), fontsize=11) plt.tight_layout() pp.savefig() plt.close(fig) diff --git a/backward_paper/runner.py b/backward_paper/runner.py index 81dd28be8..e8cada768 100644 --- a/backward_paper/runner.py +++ b/backward_paper/runner.py @@ -22,10 +22,10 @@ pkg_path = pathlib.Path(__file__).absolute().parents[0] -def rotate_to_pm_basis(log): +def rotate_to_pm_basis(log, skip=None): """Rotate to plus minus basis""" - # TODO: this can be improved rot_log = {} + skip = skip if skip is not None else [] if "g" in log: rot_log["g"] = log["g"] for pid in eko.evolution_operator.flavors.quark_names: @@ -33,22 +33,21 @@ def rotate_to_pm_basis(log): continue quark = log[pid] qbar = log[f"{pid}bar"].copy() - rot_log[r"${%s}^{+}$" % (pid)] = copy.deepcopy(log[pid]) - rot_log[r"${%s}^{-}$" % (pid)] = copy.deepcopy(log[pid]) - for column_name, column_data in quark.items(): - if column_name == "x": + for key, fact in zip(["plus", "minus"], [1, -1]): + if key in skip: continue - rot_log[r"${%s}^{+}$" % (pid)][column_name] = ( - column_data + qbar[column_name] - ) - rot_log[r"${%s}^{-}$" % (pid)][column_name] = ( - column_data - qbar[column_name] - ) + rot_log[r"${%s}^{%s}$" % (pid, key)] = copy.deepcopy(quark) + for column_name in quark: + if "x" in column_name or "error" in column_name: + continue + rot_log[r"${%s}^{%s}$" % (pid, key)][column_name] += ( + fact * qbar[column_name] + ) return rot_log -class EkoRunner(Runner): +class BackwardPaperRunner(Runner): """ Specialization of the Ekomark runner. """ @@ -56,10 +55,49 @@ class EkoRunner(Runner): def __init__(self): super().__init__() self.banana_cfg = load_config(pkg_path) + # TODO: needed ? self.rotate_to_evolution_basis = False self.plot_pdfs = [4, -4] self.sandbox = True self.fig_name = None + self.return_to_Q0 = False + + def run_me(self, theory, ocard, _pdf): + + # Go back to the inital scale? + if self.return_to_Q0: + # TODO: cache is not aware of this trick... + # Improve this + self.sandbox = False + if len(ocard["Q2grid"]) > 1: + raise ValueError( + "Q2grid must contain a single value when returning to the initial Q0" + ) + + me = super().run_me(theory, ocard, _pdf) + + # TODO: bad trick + q2_from = theory["Q0"] ** 2 + q2_to = ocard["Q2grid"][0] + theory["Q0"] = np.sqrt(q2_to) + ocard["Q2grid"] = [q2_from] + + me_back = super().run_me(theory, ocard, _pdf) + o1 = me["Q2grid"][q2_to]["operators"] + o2 = me_back["Q2grid"][q2_from]["operators"] + final_op = np.einsum("ajbk,bkcl -> ajcl", o1, o2) + + # TODO: add a test here + # for idx, op in enumerate(final_op): + # np.testing.assert_allclose(op[:,idx,:], np.eye(final_op.shape[1])) + + me_back["Q2grid"][q2_from]["operators"] = final_op + theory["Q0"] = np.sqrt(q2_from) + return me_back + else: + me = super().run_me(theory, ocard, _pdf) + + return me def run_external(self, theory, ocard, pdf): @@ -82,7 +120,7 @@ def run_external(self, theory, ocard, pdf): ext[rep] = tab return ext - def log(self, theory, ocard, _pdf, me, ext): + def log(self, theory, ocard, pdf, me, ext): """Apply PDFs to eko and produce log tables""" log_tabs = {} xgrid = ocard["interpolation_xgrid"] @@ -92,7 +130,7 @@ def log(self, theory, ocard, _pdf, me, ext): if self.rotate_to_evolution_basis: rotate_to_evolution = eko.basis_rotation.rotate_flavor_to_evolution.copy() - pdf_name = _pdf.set().name + pdf_name = pdf.set().name pdfs = lhapdf.mkPDFs(pdf_name) # build table @@ -100,9 +138,9 @@ def log(self, theory, ocard, _pdf, me, ext): tab["x"] = xgrid # Loop over pdfs replicas - for rep, pdf in enumerate(pdfs): + for rep, pdf_set in enumerate(pdfs): pdf_grid = me.apply_pdf_flavor( - pdf, + pdf_set, xgrid, flavor_rotation=rotate_to_evolution, ) @@ -122,11 +160,11 @@ def log(self, theory, ocard, _pdf, me, ext): for q2 in q2s: res = pdf_grid[q2] my_pdfs = res["pdfs"] - my_pdf_errs = res["errors"] + # my_pdf_errs = res["errors"] tab[f"EKO_@_{np.round(np.sqrt(q2), 2)}"] = xgrid * my_pdfs[key] - tab[f"EKO_error_@_{np.round(np.sqrt(q2), 2)}"] = ( - xgrid * my_pdf_errs[key] - ) + # tab[f"EKO_error_@_{np.round(np.sqrt(q2), 2)}"] = ( + # xgrid * my_pdf_errs[key] + # ) log_tab[pdfname(key)] = pd.DataFrame(tab) log_tabs[rep] = log_tab From eb769e70d5aa4d9dd0ea94735aed6a9fbd61c1a3 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 12 Jul 2021 14:11:30 +0200 Subject: [PATCH 09/71] pass Q0 to lhapdf utils --- .../benchmark/external/lhapdf_utils.py | 21 ++++++++++--------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/benchmarks/ekomark/benchmark/external/lhapdf_utils.py b/benchmarks/ekomark/benchmark/external/lhapdf_utils.py index c3533cda6..7d04ad409 100644 --- a/benchmarks/ekomark/benchmark/external/lhapdf_utils.py +++ b/benchmarks/ekomark/benchmark/external/lhapdf_utils.py @@ -7,7 +7,7 @@ from eko import basis_rotation as br -def compute_LHAPDF_data(operators, pdf, skip_pdfs, rotate_to_evolution_basis=False): +def compute_LHAPDF_data(operators, pdf, skip_pdfs, Q2s=None, rotate_to_evolution_basis=False): """ Run LHAPDF to compute operators. @@ -16,9 +16,11 @@ def compute_LHAPDF_data(operators, pdf, skip_pdfs, rotate_to_evolution_basis=Fal operators : dict operators card pdf : lhapdf_type - pdf + PDF skip_pdfs : list list of pdfs (pid or name) to skip + Q2s : list(float) + compute the pdf at the given q2, otherwise use the Q2grid values rotate_to_evolution_basis: bool rotate to evolution basis @@ -29,22 +31,22 @@ def compute_LHAPDF_data(operators, pdf, skip_pdfs, rotate_to_evolution_basis=Fal """ target_xgrid = operators["interpolation_xgrid"] - out_tabs = {} - for q2 in operators["Q2grid"]: + if Q2s is None: + Q2s = operators["Q2grid"] + # loop on q2 + for q2 in Q2s: tab = {} + + # loop on particles for pid in br.flavor_basis_pids: if pid in skip_pdfs: continue # collect lhapdf - me = [] - for x in target_xgrid: - xf = pdf.xfxQ2(pid, x, q2) - me.append(xf) - tab[pid] = np.array(me) + tab[pid] = np.array([pdf.xfxQ2(pid, x, q2) for x in target_xgrid]) # rotate if needed if rotate_to_evolution_basis: @@ -56,7 +58,6 @@ def compute_LHAPDF_data(operators, pdf, skip_pdfs, rotate_to_evolution_basis=Fal ) evol_pdf = br.rotate_flavor_to_evolution @ pdfs tab = dict(zip(br.evol_basis, evol_pdf)) - out_tabs[q2] = tab ref = { From 35c2de06bd576dfd8344fc156d5bde144ce7ec43 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 12 Jul 2021 14:13:38 +0200 Subject: [PATCH 10/71] more backward tests --- tests/test_ev_operator.py | 78 +++++++++++++++++++++++++++++++++++++++ tests/test_kernels_s.py | 11 ++++++ 2 files changed, 89 insertions(+) diff --git a/tests/test_ev_operator.py b/tests/test_ev_operator.py index d494d507d..b77815804 100644 --- a/tests/test_ev_operator.py +++ b/tests/test_ev_operator.py @@ -213,6 +213,84 @@ def test_compute(self, monkeypatch): assert k in o1.op_members np.testing.assert_allclose(o1.op_members[k].value, np.eye(2), err_msg=k) + def test_back( + self, + ): + # setup objs + theory_card = { + "alphas": 0.35, + "PTO": 0, + "ModEv": "EXA", + "fact_to_ren_scale_ratio": 1.0, + "Qref": np.sqrt(2), + "nfref": None, + "Q0": np.sqrt(2), + "IC": 1, + "IB": 1, + "mc": 1.0, + "mb": 4.75, + "mt": 173.0, + "kcThr": 1.0, + "kbThr": 1.0, + "ktThr": 1.0, + "MaxNfPdf": 6, + "MaxNfAs": 6, + } + operators_card = { + "Q2grid": [10], + "interpolation_xgrid": np.geomspace(1e-5, 1, 10), + "interpolation_polynomial_degree": 1, + "interpolation_is_log": True, + "debug_skip_singlet": False, + "debug_skip_non_singlet": False, + "ev_op_max_order": 1, + "ev_op_iterations": 1, + "backward_inversion": "exact", + } + g = OperatorGrid.from_dict( + theory_card, + operators_card, + ThresholdsAtlas.from_dict(theory_card), + StrongCoupling.from_dict(theory_card), + InterpolatorDispatcher.from_dict(operators_card), + ) + a0 = 2 + a1 = 10 + o = Operator(g.config, g.managers, 3, a0, a1) + o_back = Operator(g.config, g.managers, 3, a1, a0) + + o_back.compute() + o.compute() + + for k in ["NS_v"]: + # np.testing.assert_allclose( + # o.op_members[k].value, + # np.linalg.inv(o_back.op_members[k].value), + # atol=3e-2, + # ) + + np.testing.assert_allclose( + o.op_members[k].value @ o_back.op_members[k].value, + np.eye(o_back.op_members[k].value.shape[0]), + atol=3e-2, + rtol=2e-2, + ) + # TODO: not passing for singlet? + # np.testing.assert_allclose( + # o_back.op_members['S_qq'].value @ o.op_members['S_qq'].value + + # o_back.op_members['S_qg'].value @ o.op_members['S_gq'].value, + # np.eye(o.op_members[k].value.shape[0]), + # atol=3e-2, + # rtol=2e-2 + # ) + # np.testing.assert_allclose( + # o_back.op_members['S_qq'].value @ o.op_members['S_qg'].value + + # o_back.op_members['S_qg'].value @ o.op_members['S_gg'].value, + # np.zeros(o.op_members[k].value.shape), + # atol=3e-2, + # rtol=2e-2 + # ) + def test_pegasus_path(): def quad_ker_pegasus( diff --git a/tests/test_kernels_s.py b/tests/test_kernels_s.py index 4aeec5bf8..78f393d6a 100644 --- a/tests/test_kernels_s.py +++ b/tests/test_kernels_s.py @@ -240,3 +240,14 @@ def test_gamma_usage(): ev_op_max_order, ) assert np.isnan(r).any() + + +def test_singlet_back(): + gamma_s = np.random.rand(3, 2, 2) + np.random.rand(3, 2, 2) * 1j + nf = 4 + a1 = 3.0 + a0 = 4.0 + s10 = s.dispatcher(2, "iterate-exact", gamma_s, a1, a0, nf, 1, 1) + np.testing.assert_allclose( + np.linalg.inv(s10), s.dispatcher(2, "iterate-exact", gamma_s, a0, a1, nf, 1, 1) + ) From 892cfc7b5ba44dd5b753710125d05b6cd4844b41 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 12 Jul 2021 14:14:36 +0200 Subject: [PATCH 11/71] update runner --- backward_paper/evolve_backward.py | 30 ++++++++++++------- backward_paper/plots.py | 2 +- backward_paper/runner.py | 49 +++++++++++++------------------ 3 files changed, 42 insertions(+), 39 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 72d753a01..a941a5815 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -32,8 +32,9 @@ class BackwardRunner(BackwardPaperRunner): base_operator = { # "interpolation_xgrid": np.linspace(0.01, 1, 100), # "interpolation_xgrid": np.geomspace(0.0001, 1, 100), - #"interpolation_xgrid": eko.interpolation.make_grid(3,2).tolist(), - "backward_inversion": "expanded", + # "interpolation_xgrid": eko.interpolation.make_grid(1,1).tolist(), + # "interpolation_polynomial_degree": 1, + "backward_inversion": "exact", } def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5, return_to_Q0=False): @@ -52,13 +53,21 @@ def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5, return_to_Q0=False): if True compute also the EKO back to test stability """ self.fig_name = pdf_name - self.return_to_Q0 = return_to_Q0 operator_updates = self.base_operator.copy() operator_updates["Q2grid"] = [q_low ** 2] theory_updates = self.base_theory.copy() theory_updates["Q0"] = q_high - - self.run([theory_updates], [operator_updates], [pdf_name]) + if return_to_Q0: + self.return_to_Q0 = return_to_Q0 + theory_updates["PTO"] = 0 + theory_updates["IC"] = 1 + theory_updates["IB"] = 1 + theory_updates["ModEv"] = "TRN" + operator_updates["debug_skip_singlet"] = True + # self.rotate_to_evolution_basis = True + self.plot_pdfs = ["S", "g", "V", "T3", "T8", "V3", "V8"] + + self.run([theory_updates], [operator_updates], [pdf_name], use_replicas=True) def evolve_above_below_thr( self, pdf_name, q_high=1.65, heavy_quark="c", epsilon=0.01 @@ -89,7 +98,7 @@ def evolve_above_below_thr( ) theory_updates = self.base_theory.copy() theory_updates["Q0"] = q_high - self.run([theory_updates], [operator_updates], [pdf_name]) + self.run([theory_updates], [operator_updates], [pdf_name], use_replicas=True) if __name__ == "__main__": @@ -98,12 +107,13 @@ def evolve_above_below_thr( # Evolve below c threshold pdf_names = [ - "210629-n3fit-001", # NNLO, fitted charm - # "210629-theory-003", # NNLO, perturbative charm + # "210629-n3fit-001", # NNLO, fitted charm + "210629-theory-003", # NNLO, perturbative charm # "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c + # "NNPDF31_nnlo_pch_as_0118" ] for name in pdf_names: - myrunner.evolve_backward(name) + # myrunner.evolve_backward(name) myrunner.evolve_above_below_thr(name) # # Test perturbarive B @@ -111,4 +121,4 @@ def evolve_above_below_thr( # myrunner.evolve_above_below_thr(pdf_name, q_high=5, heavy_quark="b") # Test EKO back and forth - myrunner.evolve_backward(pdf_name, q_high=1.65, q_low=1.52, return_to_Q0=True) + # myrunner.evolve_backward(pdf_name, q_high=30, q_low=100, return_to_Q0=True) diff --git a/backward_paper/plots.py b/backward_paper/plots.py index b0da1a848..554faafe4 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -77,7 +77,7 @@ def plot_pdf(log, fig_name, cl=1): ax.legend(labels) ax.plot(np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5) - axs[1].set_yscale("symlog", linthresh=1e-7 if y_min < 1e-7 else y_min) + axs[1].set_yscale("symlog", linthresh=1e-6 if y_min < 1e-6 else y_min) axs[0].set_xscale("log") axs[0].set_ylabel(r"\rm{x %s(x)}" % quark_latex_name(name), fontsize=11) plt.tight_layout() diff --git a/backward_paper/runner.py b/backward_paper/runner.py index e8cada768..4cece0250 100644 --- a/backward_paper/runner.py +++ b/backward_paper/runner.py @@ -10,13 +10,14 @@ from banana import load_config from banana.data import dfdict +from banana.benchmark.runner import get_pdf_name from ekomark.benchmark.runner import Runner from ekomark import pdfname +from ekomark.benchmark.external.lhapdf_utils import compute_LHAPDF_data from plots import plot_pdf -import lhapdf import eko pkg_path = pathlib.Path(__file__).absolute().parents[0] @@ -55,7 +56,6 @@ class BackwardPaperRunner(Runner): def __init__(self): super().__init__() self.banana_cfg = load_config(pkg_path) - # TODO: needed ? self.rotate_to_evolution_basis = False self.plot_pdfs = [4, -4] self.sandbox = True @@ -81,15 +81,18 @@ def run_me(self, theory, ocard, _pdf): q2_to = ocard["Q2grid"][0] theory["Q0"] = np.sqrt(q2_to) ocard["Q2grid"] = [q2_from] - me_back = super().run_me(theory, ocard, _pdf) + o1 = me["Q2grid"][q2_to]["operators"] o2 = me_back["Q2grid"][q2_from]["operators"] - final_op = np.einsum("ajbk,bkcl -> ajcl", o1, o2) + final_op = np.einsum("ajbk,bkcl -> ajcl", o2, o1) # TODO: add a test here # for idx, op in enumerate(final_op): - # np.testing.assert_allclose(op[:,idx,:], np.eye(final_op.shape[1])) + # # skip ph, t, tbar, g + # if idx in [0,1,13,7]: + # continue + # np.testing.assert_allclose(op[:,idx,:], np.eye(final_op.shape[1]), atol=0.15) me_back["Q2grid"][q2_from]["operators"] = final_op theory["Q0"] = np.sqrt(q2_from) @@ -103,21 +106,7 @@ def run_external(self, theory, ocard, pdf): if self.external == "inputpdf": # Compare with the initial pdf - - xgrid = ocard["interpolation_xgrid"] - q0 = theory["Q0"] - ext = {} - pdfs = lhapdf.mkPDFs(pdf.set().name) - for rep, base_pdf in enumerate(pdfs): - tab = {} - for x in xgrid: - in_pdf = base_pdf.xfxQ(x, q0) - for pid, val in in_pdf.items(): - if pid not in tab: - tab[pid] = [] - tab[pid].append(val) - - ext[rep] = tab + ext = compute_LHAPDF_data(ocard, pdf, skip_pdfs=[], Q2s=[theory["Q0"]]) return ext def log(self, theory, ocard, pdf, me, ext): @@ -130,15 +119,14 @@ def log(self, theory, ocard, pdf, me, ext): if self.rotate_to_evolution_basis: rotate_to_evolution = eko.basis_rotation.rotate_flavor_to_evolution.copy() - pdf_name = pdf.set().name - pdfs = lhapdf.mkPDFs(pdf_name) + pdf_name = get_pdf_name(pdf) # build table tab = {} tab["x"] = xgrid # Loop over pdfs replicas - for rep, pdf_set in enumerate(pdfs): + for rep, pdf_set in enumerate(pdf): pdf_grid = me.apply_pdf_flavor( pdf_set, xgrid, @@ -149,12 +137,12 @@ def log(self, theory, ocard, pdf, me, ext): ref_pdfs = ext[rep] # Loop over pdf ids - for key in ref_pdfs: - if key not in self.plot_pdfs: - continue + for key in self.plot_pdfs: if self.external == "inputpdf": - tab[f'{pdf_name}_@_{theory["Q0"]}'] = ref_pdfs[key] + tab[f'{pdf_name}_@_{theory["Q0"]}'] = ref_pdfs["values"][ + theory["Q0"] + ][key] # Loop over q2 grid for q2 in q2s: @@ -165,6 +153,7 @@ def log(self, theory, ocard, pdf, me, ext): # tab[f"EKO_error_@_{np.round(np.sqrt(q2), 2)}"] = ( # xgrid * my_pdf_errs[key] # ) + # tab["relative_error"] = ( f - r ) / r * 100 log_tab[pdfname(key)] = pd.DataFrame(tab) log_tabs[rep] = log_tab @@ -173,5 +162,9 @@ def log(self, theory, ocard, pdf, me, ext): new_log = functools.reduce( lambda dfd1, dfd2: dfd1.merge(dfd2), log_tabs.values() ) - plot_pdf(rotate_to_pm_basis(new_log), self.fig_name, cl=1) + if self.rotate_to_evolution_basis: + plot_pdf(new_log, self.fig_name, cl=1) + else: + plot_pdf(rotate_to_pm_basis(new_log, skip=["minus"]), self.fig_name, cl=1) + return new_log From 54a78891549de4e20d369ba0ba8aa0d49dedab77 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 13 Jul 2021 15:48:52 +0200 Subject: [PATCH 12/71] Add navigator app --- backward_paper/config.py | 4 + backward_paper/evolve_backward.py | 34 +++++- backward_paper/navigator.py | 127 ++++++++++++++++++++++ backward_paper/plots.py | 6 +- backward_paper/runner.py | 25 +++-- benchmarks/ekomark/data/db.py | 1 + benchmarks/ekomark/navigator/navigator.py | 7 +- 7 files changed, 185 insertions(+), 19 deletions(-) create mode 100644 backward_paper/config.py create mode 100644 backward_paper/navigator.py diff --git a/backward_paper/config.py b/backward_paper/config.py new file mode 100644 index 000000000..1a25a65e2 --- /dev/null +++ b/backward_paper/config.py @@ -0,0 +1,4 @@ +# -*- coding: utf-8 -*- +import pathlib + +pkg_path = pathlib.Path(__file__).absolute().parents[0] diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index a941a5815..d9037c7fb 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -4,6 +4,8 @@ """ import numpy as np +from banana.data import cartesian_product + from runner import BackwardPaperRunner pid_dict = {"c": 4, "b": 5, "t": 6} @@ -93,13 +95,28 @@ def evolve_above_below_thr( thr_scale = ( self.base_theory[f"m{heavy_quark}"] * self.base_theory[f"k{heavy_quark}Thr"] ) - operator_updates["Q2grid"] = np.power( - [thr_scale + epsilon, thr_scale - epsilon], 2 + operator_updates["Q2grid"] = list( + np.power([thr_scale + epsilon, thr_scale - epsilon], 2) ) theory_updates = self.base_theory.copy() theory_updates["Q0"] = q_high self.run([theory_updates], [operator_updates], [pdf_name], use_replicas=True) + def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): + self.fig_name = pdf_name + operator_updates = self.base_operator.copy() + operator_updates["Q2grid"] = [q_low ** 2] + operator_updates["backward_inversion"] = ["exact", "expanded"] + + theory_updates = self.base_theory.copy() + theory_updates["Q0"] = q_high + self.run( + [theory_updates], + [cartesian_product(operator_updates)], + [pdf_name], + use_replicas=True, + ) + if __name__ == "__main__": @@ -113,12 +130,19 @@ def evolve_above_below_thr( # "NNPDF31_nnlo_pch_as_0118" ] for name in pdf_names: + + # # Simple inversion # myrunner.evolve_backward(name) - myrunner.evolve_above_below_thr(name) + + # # Test beclow above thr + # myrunner.evolve_above_below_thr(name) + + # # Test exapanded/exact + myrunner.evolve_exact_expanded(name) # # Test perturbarive B - pdf_name = "210629-n3fit-001" + # pdf_name = "210629-n3fit-001" # myrunner.evolve_above_below_thr(pdf_name, q_high=5, heavy_quark="b") - # Test EKO back and forth + # # Test EKO back and forth # myrunner.evolve_backward(pdf_name, q_high=30, q_low=100, return_to_Q0=True) diff --git a/backward_paper/navigator.py b/backward_paper/navigator.py new file mode 100644 index 000000000..71c0bf893 --- /dev/null +++ b/backward_paper/navigator.py @@ -0,0 +1,127 @@ +# -*- coding: utf-8 -*- +""" +This script contains a specialization of the Ekomark navigator +""" +import numpy as np +import pandas as pd + +from banana import navigator as bnav +from banana import load_config +from banana.data import dfdict + + +from ekomark.navigator.navigator import NavigatorApp as Ekonavigator + +from config import pkg_path +from runner import rotate_to_pm_basis as to_pm +from plots import plot_pdf + + +class NavigatorApp(Ekonavigator): + """ + Specialization of the Ekomark navigator. + """ + + def __init__(self, banana_cfg, external): + super().__init__(banana_cfg, external) + + def fill_logs(self, lg, obj): + """ + Collect important information of the log record. + + Parameters + ---------- + lg : dict + database record + obj : dict + to be updated pandas record + """ + obj["theory"] = lg["t_hash"][: self.hash_len] + obj["ocard"] = lg["o_hash"][: self.hash_len] + for f in ["pdf", "external"]: + obj[f] = lg[f] + + def plot_logs(self, hashes, key_to_plot, rotate_to_pm_basis=True, skip=None): + """ + Plot two different logs with the same x grid + + Parameters + ---------- + hashes : list + log hash list to plot + key_to_plot: str + key to display in the plot legend: 'pdf' or theory/operator key + rotate_to_pm_basis : bool + if True rotate to plus minus basis + skip : str + skip 'plus' or 'minus' distribution + + """ + + dfds = [] + labels = [] + fig_name = "" + for h in hashes: + log = self.get(bnav.l, h) + dfds.append(log["log"]) + fig_name += f"{log['hash'][: self.hash_len]}_" + + # search the label + if key_to_plot == "pdf": + labels.append(log["pdf"]) + else: + try: + theory = self.get(bnav.t, log["t_hash"]) + labels.append(theory[key_to_plot]) + except KeyError: + try: + operators = self.get(bnav.o, log["o_hash"]) + labels.append(operators[key_to_plot]) + except KeyError as err: + raise KeyError( + f"{key_to_plot} is neither in operator card neither in theory card" + ) from err + # build a total log table with new keys + fig_name = fig_name[:-1] + total_log = dfdict.DFdict() + for n, dfd in enumerate(dfds): + for pid, tab in dfd.items(): + # set first table + if n == 0: + total_log[pid] = pd.DataFrame( + {k.replace("EKO", f"{labels[n]}"): v for k, v in tab.items()} + ) + # set the other tables + else: + for key, vals in tab.items(): + if key == "x": + np.testing.assert_allclose(tab.x, total_log[pid].x) + else: + new_key = key.replace("EKO", f"{labels[n]}") + total_log[pid][new_key] = vals + + plot_pdf(to_pm(total_log, skip) if rotate_to_pm_basis else total_log, fig_name) + + +def launch_navigator(): + """CLI Entry point""" + return bnav.launch_navigator("eko") + + +app = NavigatorApp(load_config(pkg_path), "sandbox") + +# register banana functions +bnav.register_globals(globals(), app) + +# add my functions +dfl = app.log_as_dfd +plot_logs = app.plot_logs + +# check_log = app.check_log +# plot_pdfs = app.plot_pdfs +# display_pdfs = app.display_pdfs +# compare = app.compare_external + + +if __name__ == "__main__": + launch_navigator() diff --git a/backward_paper/plots.py b/backward_paper/plots.py index 554faafe4..3807b6db0 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -2,20 +2,18 @@ """ Plotting options """ -import pathlib import numpy as np from matplotlib import use, rc from matplotlib.backends.backend_pdf import PdfPages import matplotlib.pyplot as plt +from config import pkg_path use("PDF") rc("font", **{"family": "sans-serif", "sans-serif": ["Helvetica"]}) rc("text", usetex=True) -pkg_path = pathlib.Path(__file__).absolute().parents[0] - def quark_latex_name(name): quark_name = name @@ -55,7 +53,7 @@ def plot_pdf(log, fig_name, cl=1): labels = [] y_min = 1.0 for column_name, column_data in mean.items(): - if "x" in column_name: + if column_name == "x": continue mean.plot("x", f"{column_name}", ax=ax) diff --git a/backward_paper/runner.py b/backward_paper/runner.py index 4cece0250..90a1950e9 100644 --- a/backward_paper/runner.py +++ b/backward_paper/runner.py @@ -3,7 +3,6 @@ This script contains a specialization of the Ekomark runner """ import functools -import pathlib import copy import pandas as pd import numpy as np @@ -17,14 +16,22 @@ from ekomark.benchmark.external.lhapdf_utils import compute_LHAPDF_data from plots import plot_pdf +from config import pkg_path import eko -pkg_path = pathlib.Path(__file__).absolute().parents[0] - def rotate_to_pm_basis(log, skip=None): - """Rotate to plus minus basis""" + """ + Rotate to plus minus basis + + Parameters + ---------- + log: dict + log table + skip: str + skip 'plus' or 'minus' + """ rot_log = {} skip = skip if skip is not None else [] if "g" in log: @@ -36,11 +43,11 @@ def rotate_to_pm_basis(log, skip=None): qbar = log[f"{pid}bar"].copy() for key, fact in zip(["plus", "minus"], [1, -1]): - if key in skip: + if key == skip: continue rot_log[r"${%s}^{%s}$" % (pid, key)] = copy.deepcopy(quark) for column_name in quark: - if "x" in column_name or "error" in column_name: + if column_name == "x" or "error" in column_name: continue rot_log[r"${%s}^{%s}$" % (pid, key)][column_name] += ( fact * qbar[column_name] @@ -106,7 +113,7 @@ def run_external(self, theory, ocard, pdf): if self.external == "inputpdf": # Compare with the initial pdf - ext = compute_LHAPDF_data(ocard, pdf, skip_pdfs=[], Q2s=[theory["Q0"]]) + ext = compute_LHAPDF_data(ocard, pdf, skip_pdfs=[], Q2s=[theory["Q0"] ** 2]) return ext def log(self, theory, ocard, pdf, me, ext): @@ -141,7 +148,7 @@ def log(self, theory, ocard, pdf, me, ext): if self.external == "inputpdf": tab[f'{pdf_name}_@_{theory["Q0"]}'] = ref_pdfs["values"][ - theory["Q0"] + theory["Q0"] ** 2 ][key] # Loop over q2 grid @@ -165,6 +172,6 @@ def log(self, theory, ocard, pdf, me, ext): if self.rotate_to_evolution_basis: plot_pdf(new_log, self.fig_name, cl=1) else: - plot_pdf(rotate_to_pm_basis(new_log, skip=["minus"]), self.fig_name, cl=1) + plot_pdf(rotate_to_pm_basis(new_log, skip="minus"), self.fig_name, cl=1) return new_log diff --git a/benchmarks/ekomark/data/db.py b/benchmarks/ekomark/data/db.py index 8e795f38a..130b81453 100644 --- a/benchmarks/ekomark/data/db.py +++ b/benchmarks/ekomark/data/db.py @@ -22,3 +22,4 @@ class Operator(Base): # pylint: disable=too-few-public-methods ev_op_max_order = Column(Integer) ev_op_iterations = Column(Integer) Q2grid = Column(Text) + backward_inversion = Column(Text) diff --git a/benchmarks/ekomark/navigator/navigator.py b/benchmarks/ekomark/navigator/navigator.py index dbe35cdb3..c59ebd471 100644 --- a/benchmarks/ekomark/navigator/navigator.py +++ b/benchmarks/ekomark/navigator/navigator.py @@ -82,6 +82,7 @@ def fill_operators(self, op, obj): obj["iters"] = op["ev_op_iterations"] obj["skip_ns"] = op["debug_skip_non_singlet"] obj["skip_s"] = op["debug_skip_singlet"] + obj["backward_inversion"] = op["backward_inversion"] def fill_cache(self, cac, obj): """ @@ -94,7 +95,11 @@ def fill_cache(self, cac, obj): obj : dict to be updated pandas record """ - vals = cac["result"]["values"] + # If all the pdfs replicas were used look only a the cental value + try: + vals = cac["result"]["values"] + except KeyError: + vals = cac["result"][0]["values"] q2s = list(vals.keys()) # assume the vals are homogenous (true for bare eko results) and look # only at the first one From 31fc2b094de404148e3fa9d4ea0e56ba21d86880 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 13 Jul 2021 16:55:49 +0200 Subject: [PATCH 13/71] some fix in evolve backward --- backward_paper/evolve_backward.py | 58 +++++++++++++++++-------------- backward_paper/navigator.py | 3 -- 2 files changed, 31 insertions(+), 30 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index d9037c7fb..41eb1b2c4 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -4,7 +4,7 @@ """ import numpy as np -from banana.data import cartesian_product +from ekomark.data import operators from runner import BackwardPaperRunner @@ -36,9 +36,28 @@ class BackwardRunner(BackwardPaperRunner): # "interpolation_xgrid": np.geomspace(0.0001, 1, 100), # "interpolation_xgrid": eko.interpolation.make_grid(1,1).tolist(), # "interpolation_polynomial_degree": 1, - "backward_inversion": "exact", + "backward_inversion": ["expanded"], } + def doit( + self, pdf_name, operator_updates, theory_updates=None, q_high=None, q_low=None + ): + """Set common options and run""" + self.fig_name = pdf_name + if q_low is not None: + operator_updates["Q2grid"] = [[q_low ** 2]] + if theory_updates is None: + theory_updates = self.base_theory.copy() + if q_high is not None: + theory_updates["Q0"] = q_high + + self.run( + [theory_updates], + operators.build((operator_updates)), + [pdf_name], + use_replicas=True, + ) + def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5, return_to_Q0=False): """ Base backward evolution @@ -54,11 +73,8 @@ def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5, return_to_Q0=False): return_to_Q0: bool if True compute also the EKO back to test stability """ - self.fig_name = pdf_name operator_updates = self.base_operator.copy() - operator_updates["Q2grid"] = [q_low ** 2] theory_updates = self.base_theory.copy() - theory_updates["Q0"] = q_high if return_to_Q0: self.return_to_Q0 = return_to_Q0 theory_updates["PTO"] = 0 @@ -69,7 +85,7 @@ def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5, return_to_Q0=False): # self.rotate_to_evolution_basis = True self.plot_pdfs = ["S", "g", "V", "T3", "T8", "V3", "V8"] - self.run([theory_updates], [operator_updates], [pdf_name], use_replicas=True) + self.doit(pdf_name, operator_updates, theory_updates, q_high, q_low) def evolve_above_below_thr( self, pdf_name, q_high=1.65, heavy_quark="c", epsilon=0.01 @@ -95,27 +111,15 @@ def evolve_above_below_thr( thr_scale = ( self.base_theory[f"m{heavy_quark}"] * self.base_theory[f"k{heavy_quark}Thr"] ) - operator_updates["Q2grid"] = list( - np.power([thr_scale + epsilon, thr_scale - epsilon], 2) - ) - theory_updates = self.base_theory.copy() - theory_updates["Q0"] = q_high - self.run([theory_updates], [operator_updates], [pdf_name], use_replicas=True) + operator_updates["Q2grid"] = [ + list(np.power([thr_scale + epsilon, thr_scale - epsilon], 2)) + ] + self.doit(pdf_name, operator_updates, q_high=q_high) def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): - self.fig_name = pdf_name operator_updates = self.base_operator.copy() - operator_updates["Q2grid"] = [q_low ** 2] operator_updates["backward_inversion"] = ["exact", "expanded"] - - theory_updates = self.base_theory.copy() - theory_updates["Q0"] = q_high - self.run( - [theory_updates], - [cartesian_product(operator_updates)], - [pdf_name], - use_replicas=True, - ) + self.doit(pdf_name, operator_updates, q_high=q_high, q_low=q_low) if __name__ == "__main__": @@ -124,8 +128,8 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): # Evolve below c threshold pdf_names = [ - # "210629-n3fit-001", # NNLO, fitted charm - "210629-theory-003", # NNLO, perturbative charm + "210629-n3fit-001", # NNLO, fitted charm + # "210629-theory-003", # NNLO, perturbative charm # "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c # "NNPDF31_nnlo_pch_as_0118" ] @@ -135,10 +139,10 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): # myrunner.evolve_backward(name) # # Test beclow above thr - # myrunner.evolve_above_below_thr(name) + myrunner.evolve_above_below_thr(name) # # Test exapanded/exact - myrunner.evolve_exact_expanded(name) + # myrunner.evolve_exact_expanded(name) # # Test perturbarive B # pdf_name = "210629-n3fit-001" diff --git a/backward_paper/navigator.py b/backward_paper/navigator.py index 71c0bf893..fa936290c 100644 --- a/backward_paper/navigator.py +++ b/backward_paper/navigator.py @@ -22,9 +22,6 @@ class NavigatorApp(Ekonavigator): Specialization of the Ekomark navigator. """ - def __init__(self, banana_cfg, external): - super().__init__(banana_cfg, external) - def fill_logs(self, lg, obj): """ Collect important information of the log record. From fb8c50707596e1b3b60ed7e822f3e8e65d229ee3 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Wed, 14 Jul 2021 09:41:00 +0200 Subject: [PATCH 14/71] Add pull plot under PDF plot --- backward_paper/plots.py | 37 ++++++++++++++++++++++++++----------- 1 file changed, 26 insertions(+), 11 deletions(-) diff --git a/backward_paper/plots.py b/backward_paper/plots.py index 3807b6db0..94286122f 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -43,20 +43,25 @@ def plot_pdf(log, fig_name, cl=1): with PdfPages(path) as pp: for name, vals in log.items(): - fig, axs = plt.subplots(1, 2, figsize=(15, 5)) + fig = plt.figure(figsize=(15, 5)) + gs = fig.add_gridspec(3, 2) + # compute average and std mean = vals.groupby(["x"], axis=0, as_index=False).mean() std = vals.groupby(["x"], axis=0, as_index=False).std() - # plot pdfs - for ax in axs: + # plot pdfs with pull + # col=0 has log x, clo=1 has linear x + for ncol in [0, 1]: + + ax_ratio = plt.subplot(gs[-1:, ncol]) + ax = plt.subplot(gs[:-1, ncol], sharex=ax_ratio) labels = [] y_min = 1.0 for column_name, column_data in mean.items(): if column_name == "x": continue - mean.plot("x", f"{column_name}", ax=ax) - + ax.plot(mean.x, column_data) ax.fill_between( mean.x, column_data - cl * std[column_name], @@ -66,18 +71,28 @@ def plot_pdf(log, fig_name, cl=1): labels.append( r"\rm{ %s\ GeV\ }" % (column_name.replace("_", r"\ ")) ) - if np.abs(column_data.min()) < np.abs(y_min): y_min = np.abs(column_data.min()) - ax.set_xlabel(r"\rm{x}") - ax.set_xlim(mean.x.min(), 1.0) + ax_ratio.plot( + mean.x, column_data.div(std[column_name]).replace(np.nan, 0) + ) + + ax_ratio.set_xlim(mean.x.min(), 1.0) + ax_ratio.set_xlabel(r"\rm{x}") ax.legend(labels) ax.plot(np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5) + ax_ratio.plot( + np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5 + ) + + if ncol == 0: + ax.set_ylabel(r"\rm{x %s(x)}" % quark_latex_name(name), fontsize=11) + ax_ratio.set_ylabel(r"\rm{Pull}", fontsize=11) + ax_ratio.set_xscale("log") + else: + ax.set_yscale("symlog", linthresh=1e-6 if y_min < 1e-6 else y_min) - axs[1].set_yscale("symlog", linthresh=1e-6 if y_min < 1e-6 else y_min) - axs[0].set_xscale("log") - axs[0].set_ylabel(r"\rm{x %s(x)}" % quark_latex_name(name), fontsize=11) plt.tight_layout() pp.savefig() plt.close(fig) From 086e80e2bae0c4da112e1b7c8d26da4b0959b947 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Wed, 14 Jul 2021 14:28:21 +0200 Subject: [PATCH 15/71] Fix on talbot path and on Op initial condition --- src/eko/evolution_operator/__init__.py | 19 +++--- tests/benchmark_evol_to_unity.py | 87 ++++++++++++++++++++++++++ tests/test_ev_operator.py | 78 ----------------------- 3 files changed, 99 insertions(+), 85 deletions(-) create mode 100644 tests/benchmark_evol_to_unity.py diff --git a/src/eko/evolution_operator/__init__.py b/src/eko/evolution_operator/__init__.py index cbd8d5ac8..3f1ce3a47 100644 --- a/src/eko/evolution_operator/__init__.py +++ b/src/eko/evolution_operator/__init__.py @@ -6,6 +6,7 @@ """ import logging +from os import replace import time import numba as nb @@ -152,7 +153,9 @@ def quad_ker( """ is_singlet = mode[0] == "S" # get transformation to N integral - r = 0.4 * 16.0 / (1.0 - logx) + if logx == 0.0: + return 0.0 + r = 0.4 * 16.0 / (- logx) if is_singlet: o = 1.0 else: @@ -260,15 +263,17 @@ def compute(self): # init all ops with identity or zeros if we skip them labels = self.labels() + eye = OpMember( np.eye(grid_size), np.zeros((grid_size, grid_size))) + zero = OpMember(*[np.zeros((grid_size, grid_size))] * 2 ) for n in full_labels: if n in labels: - self.op_members[n] = OpMember( - np.eye(grid_size), np.zeros((grid_size, grid_size)) - ) + # off diag singlet are zero + if n in ["S_qg", "S_gq"]: + self.op_members[n] = zero.copy() + else: + self.op_members[n] = eye.copy() else: - self.op_members[n] = OpMember( - np.zeros((grid_size, grid_size)), np.zeros((grid_size, grid_size)) - ) + self.op_members[n] = zero.copy() # skip computation if np.isclose(self.q2_from, self.q2_to): logger.info("Evolution: skipping unity operator at %e", self.q2_from) diff --git a/tests/benchmark_evol_to_unity.py b/tests/benchmark_evol_to_unity.py new file mode 100644 index 000000000..8189a5fc0 --- /dev/null +++ b/tests/benchmark_evol_to_unity.py @@ -0,0 +1,87 @@ +# -*- coding: utf-8 -*- + +import numpy as np + +from eko.evolution_operator import Operator +from eko.evolution_operator.grid import OperatorGrid +from eko.interpolation import InterpolatorDispatcher, make_grid +from eko.strong_coupling import StrongCoupling +from eko.thresholds import ThresholdsAtlas + + +class TestBackwardForward: + # setup objs + theory_card = { + "alphas": 0.35, + "PTO": 0, + "ModEv": "EXA", + "fact_to_ren_scale_ratio": 1.0, + "Qref": np.sqrt(2), + "nfref": None, + "Q0": np.sqrt(2), + "IC": 1, + "IB": 1, + "mc": 1.0, + "mb": 4.75, + "mt": 173.0, + "kcThr": 1.0, + "kbThr": 1.0, + "ktThr": 1.0, + "MaxNfPdf": 6, + "MaxNfAs": 6, + } + operators_card = { + "Q2grid": [10], + "interpolation_xgrid": make_grid(20, 10), + "interpolation_polynomial_degree": 3, + "interpolation_is_log": True, + "debug_skip_singlet": False, + "debug_skip_non_singlet": False, + "ev_op_max_order": 1, + "ev_op_iterations": 1, + "backward_inversion": "exact", + } + + def test_op_grid( + # test that eko_forward @ eko_backward gives ID matrix or zeros + self, + ): + g = OperatorGrid.from_dict( + self.theory_card, + self.operators_card, + ThresholdsAtlas.from_dict(self.theory_card), + StrongCoupling.from_dict(self.theory_card), + InterpolatorDispatcher.from_dict(self.operators_card), + ) + q20 = 20 + q21 = 30 + o = Operator(g.config, g.managers, 3, q20, q21) + o_back = Operator(g.config, g.managers, 3, q21, q20) + o_back.compute() + o.compute() + + dim = o_back.op_members["NS_v"].value.shape + for k in ["NS_v"]: + np.testing.assert_allclose( + o.op_members[k].value @ o_back.op_members[k].value, + np.eye(dim[0]), + atol=3e-2, + rtol=2e-2, + ) + # TODO: not passing for singlet? + a = o_back.op_members["S_qq"].value @ o.op_members["S_qq"].value + b = o_back.op_members["S_qg"].value @ o.op_members["S_gq"].value + np.testing.assert_allclose( + o_back.op_members["S_qq"].value @ o.op_members["S_qq"].value + + o_back.op_members["S_qg"].value @ o.op_members["S_gq"].value, + np.eye(dim[0]), + atol=3e-2, + rtol=2e-2, + ) + np.testing.assert_allclose( + o_back.op_members["S_qq"].value @ o.op_members["S_qg"].value + + o_back.op_members["S_qg"].value @ o.op_members["S_gg"].value, + np.zeros(dim), + atol=3e-2, + rtol=2e-2, + ) diff --git a/tests/test_ev_operator.py b/tests/test_ev_operator.py index b77815804..d494d507d 100644 --- a/tests/test_ev_operator.py +++ b/tests/test_ev_operator.py @@ -213,84 +213,6 @@ def test_compute(self, monkeypatch): assert k in o1.op_members np.testing.assert_allclose(o1.op_members[k].value, np.eye(2), err_msg=k) - def test_back( - self, - ): - # setup objs - theory_card = { - "alphas": 0.35, - "PTO": 0, - "ModEv": "EXA", - "fact_to_ren_scale_ratio": 1.0, - "Qref": np.sqrt(2), - "nfref": None, - "Q0": np.sqrt(2), - "IC": 1, - "IB": 1, - "mc": 1.0, - "mb": 4.75, - "mt": 173.0, - "kcThr": 1.0, - "kbThr": 1.0, - "ktThr": 1.0, - "MaxNfPdf": 6, - "MaxNfAs": 6, - } - operators_card = { - "Q2grid": [10], - "interpolation_xgrid": np.geomspace(1e-5, 1, 10), - "interpolation_polynomial_degree": 1, - "interpolation_is_log": True, - "debug_skip_singlet": False, - "debug_skip_non_singlet": False, - "ev_op_max_order": 1, - "ev_op_iterations": 1, - "backward_inversion": "exact", - } - g = OperatorGrid.from_dict( - theory_card, - operators_card, - ThresholdsAtlas.from_dict(theory_card), - StrongCoupling.from_dict(theory_card), - InterpolatorDispatcher.from_dict(operators_card), - ) - a0 = 2 - a1 = 10 - o = Operator(g.config, g.managers, 3, a0, a1) - o_back = Operator(g.config, g.managers, 3, a1, a0) - - o_back.compute() - o.compute() - - for k in ["NS_v"]: - # np.testing.assert_allclose( - # o.op_members[k].value, - # np.linalg.inv(o_back.op_members[k].value), - # atol=3e-2, - # ) - - np.testing.assert_allclose( - o.op_members[k].value @ o_back.op_members[k].value, - np.eye(o_back.op_members[k].value.shape[0]), - atol=3e-2, - rtol=2e-2, - ) - # TODO: not passing for singlet? - # np.testing.assert_allclose( - # o_back.op_members['S_qq'].value @ o.op_members['S_qq'].value + - # o_back.op_members['S_qg'].value @ o.op_members['S_gq'].value, - # np.eye(o.op_members[k].value.shape[0]), - # atol=3e-2, - # rtol=2e-2 - # ) - # np.testing.assert_allclose( - # o_back.op_members['S_qq'].value @ o.op_members['S_qg'].value + - # o_back.op_members['S_qg'].value @ o.op_members['S_gg'].value, - # np.zeros(o.op_members[k].value.shape), - # atol=3e-2, - # rtol=2e-2 - # ) - def test_pegasus_path(): def quad_ker_pegasus( From 9c48ca08deb87129d2984d20cb95a3348b01e057 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Wed, 14 Jul 2021 14:29:11 +0200 Subject: [PATCH 16/71] Fix lhapdf_utils skip pdfs --- benchmarks/ekomark/benchmark/external/lhapdf_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/benchmarks/ekomark/benchmark/external/lhapdf_utils.py b/benchmarks/ekomark/benchmark/external/lhapdf_utils.py index 7d04ad409..2b3c228aa 100644 --- a/benchmarks/ekomark/benchmark/external/lhapdf_utils.py +++ b/benchmarks/ekomark/benchmark/external/lhapdf_utils.py @@ -42,7 +42,7 @@ def compute_LHAPDF_data(operators, pdf, skip_pdfs, Q2s=None, rotate_to_evolution # loop on particles for pid in br.flavor_basis_pids: - if pid in skip_pdfs: + if pid in skip_pdfs or not pdf.hasFlavor(pid): continue # collect lhapdf From c6d82df3e91a77f3086cb117efee6e00588295a7 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Wed, 14 Jul 2021 15:27:44 +0200 Subject: [PATCH 17/71] resotre full coverage --- src/eko/evolution_operator/__init__.py | 1 - tests/test_ev_operator.py | 4 ++-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/src/eko/evolution_operator/__init__.py b/src/eko/evolution_operator/__init__.py index 3f1ce3a47..1cdb7f1e3 100644 --- a/src/eko/evolution_operator/__init__.py +++ b/src/eko/evolution_operator/__init__.py @@ -6,7 +6,6 @@ """ import logging -from os import replace import time import numba as nb diff --git a/tests/test_ev_operator.py b/tests/test_ev_operator.py index d494d507d..5bdc5efc7 100644 --- a/tests/test_ev_operator.py +++ b/tests/test_ev_operator.py @@ -68,14 +68,14 @@ def test_quad_ker(monkeypatch): ev_op_iterations=0, ev_op_max_order=0, ) - np.testing.assert_allclose(res_ns, 1.0) + np.testing.assert_allclose(res_ns, 0.0) res_s = quad_ker( u=0, order=0, mode="S_qq", method="", is_log=is_log, - logx=0.0, + logx=1.0, areas=np.zeros(3), a1=1, a0=2, From 43e8265b98313042fbfb633fd66c768e9372f807 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Wed, 14 Jul 2021 15:29:36 +0200 Subject: [PATCH 18/71] computing momentum fraction --- backward_paper/evolve_backward.py | 13 +++--- backward_paper/navigator.py | 66 +++++++++++++++++++++++++++---- backward_paper/plots.py | 4 +- backward_paper/runner.py | 12 ++++-- 4 files changed, 76 insertions(+), 19 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 41eb1b2c4..08bf54b62 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -36,14 +36,15 @@ class BackwardRunner(BackwardPaperRunner): # "interpolation_xgrid": np.geomspace(0.0001, 1, 100), # "interpolation_xgrid": eko.interpolation.make_grid(1,1).tolist(), # "interpolation_polynomial_degree": 1, - "backward_inversion": ["expanded"], + "backward_inversion": ["expanded", "exact"], } def doit( self, pdf_name, operator_updates, theory_updates=None, q_high=None, q_low=None ): """Set common options and run""" - self.fig_name = pdf_name + if self.fig_name is None: + self.fig_name = pdf_name if q_low is not None: operator_updates["Q2grid"] = [[q_low ** 2]] if theory_updates is None: @@ -81,8 +82,8 @@ def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5, return_to_Q0=False): theory_updates["IC"] = 1 theory_updates["IB"] = 1 theory_updates["ModEv"] = "TRN" - operator_updates["debug_skip_singlet"] = True - # self.rotate_to_evolution_basis = True + # operator_updates["debug_skip_singlet"] = True + self.rotate_to_evolution_basis = True self.plot_pdfs = ["S", "g", "V", "T3", "T8", "V3", "V8"] self.doit(pdf_name, operator_updates, theory_updates, q_high, q_low) @@ -145,8 +146,8 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): # myrunner.evolve_exact_expanded(name) # # Test perturbarive B - # pdf_name = "210629-n3fit-001" + pdf_name = "210629-n3fit-001" # myrunner.evolve_above_below_thr(pdf_name, q_high=5, heavy_quark="b") # # Test EKO back and forth - # myrunner.evolve_backward(pdf_name, q_high=30, q_low=100, return_to_Q0=True) + # myrunner.evolve_backward("ToyLH", q_high=30, q_low=100, return_to_Q0=True) diff --git a/backward_paper/navigator.py b/backward_paper/navigator.py index fa936290c..c92b42b32 100644 --- a/backward_paper/navigator.py +++ b/backward_paper/navigator.py @@ -4,6 +4,7 @@ """ import numpy as np import pandas as pd +from scipy import integrate from banana import navigator as bnav from banana import load_config @@ -38,6 +39,13 @@ def fill_logs(self, lg, obj): for f in ["pdf", "external"]: obj[f] = lg[f] + @staticmethod + def get_replica(tab, n): + """Get the n-th replica""" + nrep = tab["x"].value_counts().iloc[0] + ngrid = int(len(tab) / nrep) + return tab.iloc[n * ngrid : (n + 1) * ngrid, :] + def plot_logs(self, hashes, key_to_plot, rotate_to_pm_basis=True, skip=None): """ Plot two different logs with the same x grid @@ -52,7 +60,6 @@ def plot_logs(self, hashes, key_to_plot, rotate_to_pm_basis=True, skip=None): if True rotate to plus minus basis skip : str skip 'plus' or 'minus' distribution - """ dfds = [] @@ -90,15 +97,58 @@ def plot_logs(self, hashes, key_to_plot, rotate_to_pm_basis=True, skip=None): ) # set the other tables else: - for key, vals in tab.items(): - if key == "x": - np.testing.assert_allclose(tab.x, total_log[pid].x) - else: - new_key = key.replace("EKO", f"{labels[n]}") - total_log[pid][new_key] = vals + np.testing.assert_allclose(tab.x, total_log[pid].x) + for key, vals in tab.iloc[:, 1:].items(): + new_key = key.replace("EKO", f"{labels[n]}") + total_log[pid][new_key] = vals plot_pdf(to_pm(total_log, skip) if rotate_to_pm_basis else total_log, fig_name) + def compute_momentum_fraction(self, hashes, rotate_to_pm_basis=True, skip=None): + """ + Compute the momentum fraction for each PDF + + Parameters + ---------- + hashes : list + log hash list to plot + rotate_to_pm_basis : bool + if True rotate to plus minus basis + skip : str + skip 'plus' or 'minus' distribution + """ + + def integrand(delta_x): + return lambda y: integrate.trapz(y, delta_x) + + for h in hashes: + log = self.get(bnav.l, h) + dfd = to_pm(log["log"], skip) if rotate_to_pm_basis else log["log"] + momentum_log = dfdict.DFdict() + + # loop on pdfs + for pid, tab in dfd.items(): + + # compute integral replica by replica + nrep = tab["x"].value_counts().iloc[0] + mom_df = pd.DataFrame() + for n in range(nrep): + replica_tab = get_replica(tab, n) + replica_mom = replica_tab.iloc[:, 1:].apply( + integrand(replica_tab.x) + ) + mom_df = mom_df.append(pd.DataFrame(replica_mom).T) + # average and std + momentum_log[pid] = pd.concat( + [ + mom_df.mean().rename("momentum fraction"), + mom_df.std().rename("std"), + mom_df.mean().rename("momentum fraction (%)") * 100, + ], + axis=1, + ) + print(momentum_log) + def launch_navigator(): """CLI Entry point""" @@ -113,6 +163,8 @@ def launch_navigator(): # add my functions dfl = app.log_as_dfd plot_logs = app.plot_logs +compute_mom = app.compute_momentum_fraction +get_replica = app.get_replica # check_log = app.check_log # plot_pdfs = app.plot_pdfs diff --git a/backward_paper/plots.py b/backward_paper/plots.py index 94286122f..aa259ac5a 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -58,9 +58,7 @@ def plot_pdf(log, fig_name, cl=1): ax = plt.subplot(gs[:-1, ncol], sharex=ax_ratio) labels = [] y_min = 1.0 - for column_name, column_data in mean.items(): - if column_name == "x": - continue + for column_name, column_data in mean.iloc[:, 1:].items(): ax.plot(mean.x, column_data) ax.fill_between( mean.x, diff --git a/backward_paper/runner.py b/backward_paper/runner.py index 90a1950e9..4f230d58e 100644 --- a/backward_paper/runner.py +++ b/backward_paper/runner.py @@ -46,8 +46,8 @@ def rotate_to_pm_basis(log, skip=None): if key == skip: continue rot_log[r"${%s}^{%s}$" % (pid, key)] = copy.deepcopy(quark) - for column_name in quark: - if column_name == "x" or "error" in column_name: + for column_name in quark.iloc[:, 1:]: + if "error" in column_name: continue rot_log[r"${%s}^{%s}$" % (pid, key)][column_name] += ( fact * qbar[column_name] @@ -113,7 +113,13 @@ def run_external(self, theory, ocard, pdf): if self.external == "inputpdf": # Compare with the initial pdf - ext = compute_LHAPDF_data(ocard, pdf, skip_pdfs=[], Q2s=[theory["Q0"] ** 2]) + ext = compute_LHAPDF_data( + ocard, + pdf, + skip_pdfs=[22], + Q2s=[theory["Q0"] ** 2], + rotate_to_evolution_basis=self.rotate_to_evolution_basis, + ) return ext def log(self, theory, ocard, pdf, me, ext): From 30258d9b8aa45930ed3f97d0099cb61de72cb520 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Wed, 14 Jul 2021 16:01:14 +0200 Subject: [PATCH 19/71] Adding init method to ekomark runners --- benchmarks/runners/CT14_bench.py | 8 +++++--- benchmarks/runners/NNPDF_bench.py | 8 +++++--- benchmarks/runners/apfel_bench.py | 8 +++++--- benchmarks/runners/lha_paper_bench.py | 8 +++++--- benchmarks/runners/pegasus_bench.py | 11 ++++++----- benchmarks/runners/sandbox.py | 16 +++++++++------- 6 files changed, 35 insertions(+), 24 deletions(-) diff --git a/benchmarks/runners/CT14_bench.py b/benchmarks/runners/CT14_bench.py index e65f5df41..c489f502f 100644 --- a/benchmarks/runners/CT14_bench.py +++ b/benchmarks/runners/CT14_bench.py @@ -14,10 +14,12 @@ class LHAPDFBenchmark(Runner): Globally set the external program to LHAPDF """ - external = "LHAPDF" + def __init__(self): + super().__init__() + self.external = "LHAPDF" - # Rotate to evolution basis - rotate_to_evolution_basis = False + # Rotate to evolution basis + self.rotate_to_evolution_basis = False base_theory = { diff --git a/benchmarks/runners/NNPDF_bench.py b/benchmarks/runners/NNPDF_bench.py index 6bffa04fc..6011c50f4 100644 --- a/benchmarks/runners/NNPDF_bench.py +++ b/benchmarks/runners/NNPDF_bench.py @@ -11,10 +11,12 @@ class LHAPDFBenchmark(Runner): Globally set the external program to LHAPDF """ - external = "LHAPDF" + def __init__(self): + super().__init__() + self.external = "LHAPDF" - # Rotate to evolution basis - rotate_to_evolution_basis = True + # Rotate to evolution basis + self.rotate_to_evolution_basis = True base_theory = { diff --git a/benchmarks/runners/apfel_bench.py b/benchmarks/runners/apfel_bench.py index cb8c791ba..8b5da8797 100644 --- a/benchmarks/runners/apfel_bench.py +++ b/benchmarks/runners/apfel_bench.py @@ -22,10 +22,12 @@ class ApfelBenchmark(Runner): Globally set the external program to Apfel """ - external = "apfel" + def __init__(self): + super().__init__() + self.external = "apfel" - # Rotate to evolution basis - rotate_to_evolution_basis = True + # Rotate to evolution basis + self.rotate_to_evolution_basis = True @staticmethod def skip_pdfs(_theory): diff --git a/benchmarks/runners/lha_paper_bench.py b/benchmarks/runners/lha_paper_bench.py index b150fb372..e88a4cdfb 100644 --- a/benchmarks/runners/lha_paper_bench.py +++ b/benchmarks/runners/lha_paper_bench.py @@ -33,11 +33,13 @@ class LHABenchmark(Runner): Globally set the external program to LHA """ - external = "LHA" + def __init__(self): + super().__init__() + self.external = "LHA" - theory = {} + self.theory = {} - rotate_to_evolution_basis = True + self.rotate_to_evolution_basis = True def plain_theory(self, pto): """ diff --git a/benchmarks/runners/pegasus_bench.py b/benchmarks/runners/pegasus_bench.py index 5dbc8fc33..2255b8781 100644 --- a/benchmarks/runners/pegasus_bench.py +++ b/benchmarks/runners/pegasus_bench.py @@ -25,10 +25,11 @@ class PegasusBenchmark(Runner): subleading (~ 1e-4 relative difference). """ - external = "pegasus" - - # Rotate to evolution basis - rotate_to_evolution_basis = True + def __init__(self): + super().__init__() + self.external = "pegasus" + # Rotate to evolution basis + self.rotate_to_evolution_basis = True @staticmethod def skip_pdfs(_theory): @@ -136,7 +137,7 @@ def benchmark_sv(self, pto): obj = BenchmarkVFNS() # obj = BenchmarkFFNS() - obj.benchmark_plain(1) + obj.benchmark_plain(2) # obj.benchmark_sv(1) # vfns.benchmark_sv() diff --git a/benchmarks/runners/sandbox.py b/benchmarks/runners/sandbox.py index 6b7774bd2..76901dfc9 100644 --- a/benchmarks/runners/sandbox.py +++ b/benchmarks/runners/sandbox.py @@ -28,16 +28,18 @@ class Sandbox(Runner): Globally set the external program """ - sandbox = True + def __init__(self): + super().__init__() + self.sandbox = True - # select here the external program between LHA, LHAPDF, apfel, pegasus - external = "apfel" - # external = "pegasus" + # select here the external program between LHA, LHAPDF, apfel, pegasus + self.external = "apfel" + # external = "pegasus" - # select to plot operators - plot_operator = False + # select to plot operators + self.plot_operator = False - rotate_to_evolution_basis = True + self.rotate_to_evolution_basis = True @staticmethod def generate_operators(): From c870d395cf1ca3a083499cb1f312c01ea40412fd Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 15 Jul 2021 16:57:02 +0200 Subject: [PATCH 20/71] improve bench evol to unity --- tests/benchmark_evol_to_unity.py | 87 +++++++++++++++++++++++++------- tests/test_kernels_s.py | 8 +-- 2 files changed, 74 insertions(+), 21 deletions(-) diff --git a/tests/benchmark_evol_to_unity.py b/tests/benchmark_evol_to_unity.py index 8189a5fc0..342dcaf85 100644 --- a/tests/benchmark_evol_to_unity.py +++ b/tests/benchmark_evol_to_unity.py @@ -7,6 +7,7 @@ from eko.interpolation import InterpolatorDispatcher, make_grid from eko.strong_coupling import StrongCoupling from eko.thresholds import ThresholdsAtlas +from eko.matching_conditions.operator_matrix_element import OperatorMatrixElement class TestBackwardForward: @@ -32,8 +33,9 @@ class TestBackwardForward: } operators_card = { "Q2grid": [10], - "interpolation_xgrid": make_grid(20, 10), - "interpolation_polynomial_degree": 3, + # here you need a very dense grid + "interpolation_xgrid": np.linspace(1e-1,5e-1,30), + "interpolation_polynomial_degree": 1, "interpolation_is_log": True, "debug_skip_singlet": False, "debug_skip_non_singlet": False, @@ -41,8 +43,15 @@ class TestBackwardForward: "ev_op_iterations": 1, "backward_inversion": "exact", } + g = OperatorGrid.from_dict( + theory_card, + operators_card, + ThresholdsAtlas.from_dict(theory_card), + StrongCoupling.from_dict(theory_card), + InterpolatorDispatcher.from_dict(operators_card), + ) - def test_op_grid( + def test_operator_grid( # test that eko_forward @ eko_backward gives ID matrix or zeros self, ): @@ -53,35 +62,77 @@ def test_op_grid( StrongCoupling.from_dict(self.theory_card), InterpolatorDispatcher.from_dict(self.operators_card), ) - q20 = 20 - q21 = 30 - o = Operator(g.config, g.managers, 3, q20, q21) - o_back = Operator(g.config, g.managers, 3, q21, q20) - o_back.compute() + q20 = 30 + q21 = 50 + nf = 4 + o = Operator(g.config, g.managers, nf, q20, q21) + o_back = Operator(g.config, g.managers, nf, q21, q20) o.compute() + o_back.compute() dim = o_back.op_members["NS_v"].value.shape - for k in ["NS_v"]: + for k in ["NS_v", "NS_m", "NS_p"]: np.testing.assert_allclose( o.op_members[k].value @ o_back.op_members[k].value, np.eye(dim[0]), - atol=3e-2, - rtol=2e-2, + atol=7e-2, ) - # TODO: not passing for singlet? - a = o_back.op_members["S_qq"].value @ o.op_members["S_qq"].value - b = o_back.op_members["S_qg"].value @ o.op_members["S_gq"].value + # qq np.testing.assert_allclose( o_back.op_members["S_qq"].value @ o.op_members["S_qq"].value + o_back.op_members["S_qg"].value @ o.op_members["S_gq"].value, np.eye(dim[0]), - atol=3e-2, - rtol=2e-2, + atol=7e-2, ) + # qg np.testing.assert_allclose( o_back.op_members["S_qq"].value @ o.op_members["S_qg"].value + o_back.op_members["S_qg"].value @ o.op_members["S_gg"].value, np.zeros(dim), - atol=3e-2, - rtol=2e-2, + atol=7e-4, + ) + # gg + np.testing.assert_allclose( + o_back.op_members["S_gg"].value @ o.op_members["S_gg"].value + + o_back.op_members["S_gq"].value @ o.op_members["S_qg"].value, + np.eye(dim[0]), + atol=9e-2, ) + # gq + np.testing.assert_allclose( + o_back.op_members["S_gg"].value @ o.op_members["S_gq"].value + + o_back.op_members["S_gq"].value @ o.op_members["S_qq"].value, + np.zeros(dim), + atol=3e-4, + ) + + # def test_matching_grid( + # self, + # ): + # # test matching_ome_forward @ matching_ome_backward gives ID matrix or zeros + # # Only singlet matrix is tested + # q2 = 5 + # L = 0 + # ome = OperatorMatrixElement(self.g.config, self.g.managers, is_backward=False) + # ome_back = OperatorMatrixElement(self.g.config, self.g.managers, is_backward=True) + # ome.compute( q2, L) + # ome_back.compute(q2, L) + + # dim = ome.ome_members["S_qq"].value.shape + # ome_tensor = np.zeros((3,3,dim[0],dim[0])) + # ome_tensor_back = ome_tensor + # idx_dict = dict(zip(["g", "q", "H"],[0,1,2])) + # for p1, j in idx_dict.items(): + # for p2, k in idx_dict.items(): + # ome_tensor[j,k] = ome.ome_members[f"S_{p1}{p2}"].value + # ome_tensor_back[j,k] = ome_back.ome_members[f"S_{p1}{p2}"].value + + # ome_product = np.einsum("abjk,bckl -> acjl", ome_tensor_back, ome_tensor) + # for j, line in enumerate(ome_product): + # for k, elem in enumerate(line): + # test_matrix = np.zeros(dim) if j != k else np.eye(dim[0]) + # np.testing.assert_allclose( + # elem, + # test_matrix, + # atol=7e-2, + # ) diff --git a/tests/test_kernels_s.py b/tests/test_kernels_s.py index 78f393d6a..fd556e4a8 100644 --- a/tests/test_kernels_s.py +++ b/tests/test_kernels_s.py @@ -243,11 +243,13 @@ def test_gamma_usage(): def test_singlet_back(): - gamma_s = np.random.rand(3, 2, 2) + np.random.rand(3, 2, 2) * 1j + order = 2 + gamma_s = np.random.rand(order + 1, 2, 2) + np.random.rand(order + 1, 2, 2) * 1j nf = 4 a1 = 3.0 a0 = 4.0 - s10 = s.dispatcher(2, "iterate-exact", gamma_s, a1, a0, nf, 1, 1) + s10 = s.dispatcher(order, "iterate-exact", gamma_s, a1, a0, nf, 15, 1) np.testing.assert_allclose( - np.linalg.inv(s10), s.dispatcher(2, "iterate-exact", gamma_s, a0, a1, nf, 1, 1) + np.linalg.inv(s10), + s.dispatcher(order, "iterate-exact", gamma_s, a0, a1, nf, 15, 1), ) From d02a17902ac3fdf03b30ca1c1641a3ece94a9223 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Fri, 16 Jul 2021 18:02:47 +0200 Subject: [PATCH 21/71] fix back and forth test accuracy --- tests/benchmark_evol_to_unity.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/benchmark_evol_to_unity.py b/tests/benchmark_evol_to_unity.py index 342dcaf85..242131fe5 100644 --- a/tests/benchmark_evol_to_unity.py +++ b/tests/benchmark_evol_to_unity.py @@ -34,7 +34,8 @@ class TestBackwardForward: operators_card = { "Q2grid": [10], # here you need a very dense grid - "interpolation_xgrid": np.linspace(1e-1,5e-1,30), + "interpolation_xgrid": np.linspace(1e-1,1,30), + #"interpolation_xgrid": make_grid(30,30, x_min=1e-3), "interpolation_polynomial_degree": 1, "interpolation_is_log": True, "debug_skip_singlet": False, @@ -103,7 +104,7 @@ def test_operator_grid( o_back.op_members["S_gg"].value @ o.op_members["S_gq"].value + o_back.op_members["S_gq"].value @ o.op_members["S_qq"].value, np.zeros(dim), - atol=3e-4, + atol=2e-3, ) # def test_matching_grid( From 1f775fae6d02fbea429ef39bb7afa9d6d9ea0eb6 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Fri, 16 Jul 2021 18:14:18 +0200 Subject: [PATCH 22/71] Improve plot options, fix back and forth tests --- backward_paper/evolve_backward.py | 35 +++++++++-------- backward_paper/navigator.py | 21 ++++++++-- backward_paper/plots.py | 65 +++++++++++++++++++++++-------- backward_paper/runner.py | 37 +++++++++++------- 4 files changed, 108 insertions(+), 50 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 08bf54b62..d4e220396 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -5,6 +5,7 @@ import numpy as np from ekomark.data import operators +from eko.interpolation import make_grid from runner import BackwardPaperRunner @@ -30,13 +31,13 @@ class BackwardRunner(BackwardPaperRunner): "ktThr": 1.0, "PTO": 2, "IC": 1, + "IB": 1, } base_operator = { - # "interpolation_xgrid": np.linspace(0.01, 1, 100), - # "interpolation_xgrid": np.geomspace(0.0001, 1, 100), - # "interpolation_xgrid": eko.interpolation.make_grid(1,1).tolist(), + # "interpolation_xgrid": [np.linspace(1e-1,1,50)], + # "interpolation_xgrid": [make_grid(30,30, x_min=1e-3).tolist()], # "interpolation_polynomial_degree": 1, - "backward_inversion": ["expanded", "exact"], + "backward_inversion": ["exact"] # ["expanded","exact"], } def doit( @@ -78,13 +79,12 @@ def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5, return_to_Q0=False): theory_updates = self.base_theory.copy() if return_to_Q0: self.return_to_Q0 = return_to_Q0 - theory_updates["PTO"] = 0 + self.fig_name = f"back_forth_{pdf_name}_{q_low}_{q_high}" theory_updates["IC"] = 1 theory_updates["IB"] = 1 - theory_updates["ModEv"] = "TRN" - # operator_updates["debug_skip_singlet"] = True self.rotate_to_evolution_basis = True - self.plot_pdfs = ["S", "g", "V", "T3", "T8", "V3", "V8"] + self.plot_pdfs = ["S", "g", "V"] + # self.plot_pdfs = [21, -5, 5] self.doit(pdf_name, operator_updates, theory_updates, q_high, q_low) @@ -134,20 +134,23 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): # "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c # "NNPDF31_nnlo_pch_as_0118" ] - for name in pdf_names: + # for name in pdf_names: - # # Simple inversion - # myrunner.evolve_backward(name) + # # # Simple inversion + # # myrunner.evolve_backward(name) - # # Test beclow above thr - myrunner.evolve_above_below_thr(name) + # # # Test beclow above thr + # myrunner.evolve_above_below_thr(name) - # # Test exapanded/exact - # myrunner.evolve_exact_expanded(name) + # # # Test exapanded/exact + # # myrunner.evolve_exact_expanded(name) # # Test perturbarive B pdf_name = "210629-n3fit-001" + # pdf_name = "ToyLH" # myrunner.evolve_above_below_thr(pdf_name, q_high=5, heavy_quark="b") + # myrunner.evolve_backward(pdf_name, q_low=5, q_high=4.91, return_to_Q0=True) + # myrunner.evolve_backward(pdf_name, q_low=4.91, q_high=5, return_to_Q0=True) # # Test EKO back and forth - # myrunner.evolve_backward("ToyLH", q_high=30, q_low=100, return_to_Q0=True) + myrunner.evolve_backward(pdf_name, q_high=30, q_low=100, return_to_Q0=True) diff --git a/backward_paper/navigator.py b/backward_paper/navigator.py index c92b42b32..51f391e0f 100644 --- a/backward_paper/navigator.py +++ b/backward_paper/navigator.py @@ -46,7 +46,15 @@ def get_replica(tab, n): ngrid = int(len(tab) / nrep) return tab.iloc[n * ngrid : (n + 1) * ngrid, :] - def plot_logs(self, hashes, key_to_plot, rotate_to_pm_basis=True, skip=None): + def plot_logs( + self, + hashes, + key_to_plot=None, + rotate_to_pm_basis=True, + skip=None, + plot_pull=False, + plot_reldiff=False, + ): """ Plot two different logs with the same x grid @@ -73,7 +81,7 @@ def plot_logs(self, hashes, key_to_plot, rotate_to_pm_basis=True, skip=None): # search the label if key_to_plot == "pdf": labels.append(log["pdf"]) - else: + elif key_to_plot is not None: try: theory = self.get(bnav.t, log["t_hash"]) labels.append(theory[key_to_plot]) @@ -85,6 +93,8 @@ def plot_logs(self, hashes, key_to_plot, rotate_to_pm_basis=True, skip=None): raise KeyError( f"{key_to_plot} is neither in operator card neither in theory card" ) from err + else: + labels.append("EKO") # build a total log table with new keys fig_name = fig_name[:-1] total_log = dfdict.DFdict() @@ -102,7 +112,12 @@ def plot_logs(self, hashes, key_to_plot, rotate_to_pm_basis=True, skip=None): new_key = key.replace("EKO", f"{labels[n]}") total_log[pid][new_key] = vals - plot_pdf(to_pm(total_log, skip) if rotate_to_pm_basis else total_log, fig_name) + plot_pdf( + to_pm(total_log, skip) if rotate_to_pm_basis else total_log, + fig_name, + plot_reldiff=plot_reldiff, + plot_pull=plot_pull, + ) def compute_momentum_fraction(self, hashes, rotate_to_pm_basis=True, skip=None): """ diff --git a/backward_paper/plots.py b/backward_paper/plots.py index aa259ac5a..718b1348d 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -24,7 +24,7 @@ def quark_latex_name(name): return quark_name -def plot_pdf(log, fig_name, cl=1): +def plot_pdf(log, fig_name, cl=1, plot_pull=False, plot_reldiff=False): """ Plotting routine @@ -40,11 +40,13 @@ def plot_pdf(log, fig_name, cl=1): path = pkg_path / f"{fig_name}.pdf" print(f"Writing pdf plots to {path}") + has_ratio = plot_pull or plot_reldiff + with PdfPages(path) as pp: for name, vals in log.items(): fig = plt.figure(figsize=(15, 5)) - gs = fig.add_gridspec(3, 2) + gs = fig.add_gridspec(3, 2) if has_ratio else fig.add_gridspec(1, 2) # compute average and std mean = vals.groupby(["x"], axis=0, as_index=False).mean() @@ -54,8 +56,11 @@ def plot_pdf(log, fig_name, cl=1): # col=0 has log x, clo=1 has linear x for ncol in [0, 1]: - ax_ratio = plt.subplot(gs[-1:, ncol]) - ax = plt.subplot(gs[:-1, ncol], sharex=ax_ratio) + ax = ( + plt.subplot(gs[:-1, ncol]) + if has_ratio + else plt.subplot(gs[:, ncol]) + ) labels = [] y_min = 1.0 for column_name, column_data in mean.iloc[:, 1:].items(): @@ -67,30 +72,58 @@ def plot_pdf(log, fig_name, cl=1): alpha=0.2, ) labels.append( - r"\rm{ %s\ GeV\ }" % (column_name.replace("_", r"\ ")) + r"\rm{ %s\ GeV\ }" + % ( + (column_name.replace("_", r"\ ")).replace( + ">", r"$\rightarrow$" + ) + ) ) if np.abs(column_data.min()) < np.abs(y_min): y_min = np.abs(column_data.min()) - ax_ratio.plot( - mean.x, column_data.div(std[column_name]).replace(np.nan, 0) - ) - - ax_ratio.set_xlim(mean.x.min(), 1.0) - ax_ratio.set_xlabel(r"\rm{x}") + ax.set_xlim(mean.x.min(), 1.0) ax.legend(labels) ax.plot(np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5) - ax_ratio.plot( - np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5 - ) if ncol == 0: ax.set_ylabel(r"\rm{x %s(x)}" % quark_latex_name(name), fontsize=11) - ax_ratio.set_ylabel(r"\rm{Pull}", fontsize=11) - ax_ratio.set_xscale("log") + ax.set_xscale("log") else: ax.set_yscale("symlog", linthresh=1e-6 if y_min < 1e-6 else y_min) + if plot_pull: + ax_ratio = plt.subplot(gs[-1:, ncol], sharex=ax) + for column_name, column_data in mean.iloc[:, 1:].items(): + ax_ratio.plot( + mean.x, column_data.div(std[column_name]).replace(np.nan, 0) + ) + ax_ratio.plot( + np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5 + ) + ax_ratio.set_xlabel(r"\rm{x}") + ax_ratio.set_ylabel(r"\rm{Pull}", fontsize=11) + elif plot_reldiff: + ax_ratio = plt.subplot(gs[-1:, ncol], sharex=ax) + ref_data = mean.iloc[:, 1] + for column_name, column_data in mean.iloc[:, 2:].items(): + # TODO: set colors correctly + ax_ratio.plot( + mean.x, + (column_data - ref_data).div(ref_data).replace(np.nan, 0) + * 100, + color="#ff7f0e", + ) + ax_ratio.plot( + np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5 + ) + ax_ratio.set_xlabel(r"\rm{x}") + ax_ratio.set_ylabel(r"\rm{\% difference}", fontsize=11) + ax_ratio.set_yscale("symlog", linthresh=1e-1) + ax_ratio.set_ylim(-100, 100) + else: + ax.set_xlabel(r"\rm{x}") + plt.tight_layout() pp.savefig() plt.close(fig) diff --git a/backward_paper/runner.py b/backward_paper/runner.py index 4f230d58e..f943630b7 100644 --- a/backward_paper/runner.py +++ b/backward_paper/runner.py @@ -83,7 +83,6 @@ def run_me(self, theory, ocard, _pdf): me = super().run_me(theory, ocard, _pdf) - # TODO: bad trick q2_from = theory["Q0"] ** 2 q2_to = ocard["Q2grid"][0] theory["Q0"] = np.sqrt(q2_to) @@ -94,15 +93,17 @@ def run_me(self, theory, ocard, _pdf): o2 = me_back["Q2grid"][q2_from]["operators"] final_op = np.einsum("ajbk,bkcl -> ajcl", o2, o1) - # TODO: add a test here # for idx, op in enumerate(final_op): - # # skip ph, t, tbar, g - # if idx in [0,1,13,7]: + # # skip ph, t, tbar, + # if idx in [0,1,13]: # continue - # np.testing.assert_allclose(op[:,idx,:], np.eye(final_op.shape[1]), atol=0.15) + # np.testing.assert_allclose(op[:,idx,:], np.eye(final_op.shape[1]), atol=0.01) me_back["Q2grid"][q2_from]["operators"] = final_op + # restore the Q2 values theory["Q0"] = np.sqrt(q2_from) + ocard["Q2grid"] = [q2_to] + me_back["q2_ref"] = q2_from return me_back else: me = super().run_me(theory, ocard, _pdf) @@ -126,7 +127,7 @@ def log(self, theory, ocard, pdf, me, ext): """Apply PDFs to eko and produce log tables""" log_tabs = {} xgrid = ocard["interpolation_xgrid"] - q2s = ocard["Q2grid"] + q2s = me["Q2grid"] rotate_to_evolution = None if self.rotate_to_evolution_basis: @@ -162,11 +163,12 @@ def log(self, theory, ocard, pdf, me, ext): res = pdf_grid[q2] my_pdfs = res["pdfs"] # my_pdf_errs = res["errors"] - tab[f"EKO_@_{np.round(np.sqrt(q2), 2)}"] = xgrid * my_pdfs[key] - # tab[f"EKO_error_@_{np.round(np.sqrt(q2), 2)}"] = ( - # xgrid * my_pdf_errs[key] - # ) - # tab["relative_error"] = ( f - r ) / r * 100 + if self.return_to_Q0: + tab[ + f"EKO_@_{np.round(np.sqrt(q2), 2)}_>_{np.round(np.sqrt(ocard['Q2grid'][0]), 2)}_>_{np.round(np.sqrt(q2), 2)}" + ] = (xgrid * my_pdfs[key]) + else: + tab[f"EKO_@_{np.round(np.sqrt(q2), 2)}"] = xgrid * my_pdfs[key] log_tab[pdfname(key)] = pd.DataFrame(tab) log_tabs[rep] = log_tab @@ -175,9 +177,14 @@ def log(self, theory, ocard, pdf, me, ext): new_log = functools.reduce( lambda dfd1, dfd2: dfd1.merge(dfd2), log_tabs.values() ) - if self.rotate_to_evolution_basis: - plot_pdf(new_log, self.fig_name, cl=1) - else: - plot_pdf(rotate_to_pm_basis(new_log, skip="minus"), self.fig_name, cl=1) + + plot_pdf( + rotate_to_pm_basis(new_log, skip="minus") + if self.rotate_to_evolution_basis + else new_log, + self.fig_name, + cl=1, + plot_reldiff=self.return_to_Q0, + ) return new_log From f906cb5595e12918100caa8bff7196d9849b14e2 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 19 Jul 2021 10:04:07 +0200 Subject: [PATCH 23/71] Adding cache to return_to_q0 --- backward_paper/evolve_backward.py | 16 +++++-- backward_paper/plots.py | 6 +-- backward_paper/runner.py | 77 ++++++++++++++++++------------- 3 files changed, 60 insertions(+), 39 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index d4e220396..a58260513 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -79,14 +79,19 @@ def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5, return_to_Q0=False): theory_updates = self.base_theory.copy() if return_to_Q0: self.return_to_Q0 = return_to_Q0 - self.fig_name = f"back_forth_{pdf_name}_{q_low}_{q_high}" + self.fig_name = f"back_forth_{pdf_name}_{q_low}_{q_high}_{operator_updates['backward_inversion'][0]}" theory_updates["IC"] = 1 theory_updates["IB"] = 1 self.rotate_to_evolution_basis = True self.plot_pdfs = ["S", "g", "V"] - # self.plot_pdfs = [21, -5, 5] + #self.plot_pdfs = [21, -5, 5] + # self.plot_pdfs = [21, -4, 4] - self.doit(pdf_name, operator_updates, theory_updates, q_high, q_low) + operator_updates["Q2grid"] = [[q_low ** 2], [q_high ** 2], [q_high ** 2]] + theory_updates["Q0"] = [q_high, q_low, q_high] + return self.doit(pdf_name, operator_updates, theory_updates) + + return self.doit(pdf_name, operator_updates, theory_updates, q_high, q_low) def evolve_above_below_thr( self, pdf_name, q_high=1.65, heavy_quark="c", epsilon=0.01 @@ -153,4 +158,7 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): # myrunner.evolve_backward(pdf_name, q_low=4.91, q_high=5, return_to_Q0=True) # # Test EKO back and forth - myrunner.evolve_backward(pdf_name, q_high=30, q_low=100, return_to_Q0=True) + myrunner.evolve_backward(pdf_name, q_high=5, q_low=30, return_to_Q0=True) + + # opposite not making sense, pdf at 1.5 is not defined + #myrunner.evolve_backward(pdf_name, q_low=1.5, q_high=1.65, return_to_Q0=True) diff --git a/backward_paper/plots.py b/backward_paper/plots.py index 718b1348d..6609d7ef8 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -7,6 +7,7 @@ from matplotlib import use, rc from matplotlib.backends.backend_pdf import PdfPages import matplotlib.pyplot as plt +import pandas as pd from config import pkg_path @@ -106,13 +107,12 @@ def plot_pdf(log, fig_name, cl=1, plot_pull=False, plot_reldiff=False): elif plot_reldiff: ax_ratio = plt.subplot(gs[-1:, ncol], sharex=ax) ref_data = mean.iloc[:, 1] - for column_name, column_data in mean.iloc[:, 2:].items(): - # TODO: set colors correctly + for idx, (_, column_data) in enumerate(mean.iloc[:, 2:].items()): ax_ratio.plot( mean.x, (column_data - ref_data).div(ref_data).replace(np.nan, 0) * 100, - color="#ff7f0e", + color=plt.rcParams['axes.prop_cycle'].by_key()['color'][idx+1], ) ax_ratio.plot( np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5 diff --git a/backward_paper/runner.py b/backward_paper/runner.py index f943630b7..2ed7c497d 100644 --- a/backward_paper/runner.py +++ b/backward_paper/runner.py @@ -68,46 +68,53 @@ def __init__(self): self.sandbox = True self.fig_name = None self.return_to_Q0 = False + self.ekos = [] + self.intermediate_Q = None - def run_me(self, theory, ocard, _pdf): - - # Go back to the inital scale? + def run(self, theory_updates, ocard_updates, pdfs, use_replicas=False): if self.return_to_Q0: - # TODO: cache is not aware of this trick... - # Improve this - self.sandbox = False - if len(ocard["Q2grid"]) > 1: - raise ValueError( - "Q2grid must contain a single value when returning to the initial Q0" - ) + # prevent to run all the possible runcards combinations + # but only the sequence: q0->q1->q0 + self.ekos = [] + for idx, q0 in enumerate(theory_updates[0]["Q0"]): + temp_theory = copy.deepcopy(theory_updates) + temp_theory[0]["Q0"] = q0 + super().run(temp_theory, [ocard_updates[idx]], pdfs, use_replicas) + else: + super().run(theory_updates, ocard_updates, pdfs, use_replicas) + def run_me(self, theory, ocard, _pdf): + # need to run or do an eko product? + if len(self.ekos) != 2: me = super().run_me(theory, ocard, _pdf) + # need to store the eko here? + if self.return_to_Q0: + self.ekos.append(me) + else: + self.console.print("Computing product between the prevoius Ekos") - q2_from = theory["Q0"] ** 2 - q2_to = ocard["Q2grid"][0] - theory["Q0"] = np.sqrt(q2_to) - ocard["Q2grid"] = [q2_from] - me_back = super().run_me(theory, ocard, _pdf) + # get the operator tensors + op_list = [] + for eko in self.ekos: + for operators in eko["Q2grid"].values(): + op_list.append(operators["operators"]) + + # do tensor product + final_op = np.einsum("ajbk,bkcl -> ajcl", op_list[1], op_list[0]) - o1 = me["Q2grid"][q2_to]["operators"] - o2 = me_back["Q2grid"][q2_from]["operators"] - final_op = np.einsum("ajbk,bkcl -> ajcl", o2, o1) + # set the final eko values + me = copy.deepcopy(self.ekos[1]) + self.intermediate_Q = np.round(np.sqrt(self.ekos[1]["q2_ref"]), 2) + q2_from = theory["Q0"] ** 2 + me["q2_ref"] = q2_from + me["Q2grid"][q2_from]["operators"] = final_op + # test? # for idx, op in enumerate(final_op): # # skip ph, t, tbar, # if idx in [0,1,13]: # continue # np.testing.assert_allclose(op[:,idx,:], np.eye(final_op.shape[1]), atol=0.01) - - me_back["Q2grid"][q2_from]["operators"] = final_op - # restore the Q2 values - theory["Q0"] = np.sqrt(q2_from) - ocard["Q2grid"] = [q2_to] - me_back["q2_ref"] = q2_from - return me_back - else: - me = super().run_me(theory, ocard, _pdf) - return me def run_external(self, theory, ocard, pdf): @@ -163,9 +170,9 @@ def log(self, theory, ocard, pdf, me, ext): res = pdf_grid[q2] my_pdfs = res["pdfs"] # my_pdf_errs = res["errors"] - if self.return_to_Q0: + if self.intermediate_Q: tab[ - f"EKO_@_{np.round(np.sqrt(q2), 2)}_>_{np.round(np.sqrt(ocard['Q2grid'][0]), 2)}_>_{np.round(np.sqrt(q2), 2)}" + f"EKO_@_{np.round(np.sqrt(q2), 2)}_>_{self.intermediate_Q}_>_{np.round(np.sqrt(q2), 2)}" ] = (xgrid * my_pdfs[key]) else: tab[f"EKO_@_{np.round(np.sqrt(q2), 2)}"] = xgrid * my_pdfs[key] @@ -173,14 +180,20 @@ def log(self, theory, ocard, pdf, me, ext): log_tab[pdfname(key)] = pd.DataFrame(tab) log_tabs[rep] = log_tab - # Plot + # Merge dfd for different replicas new_log = functools.reduce( lambda dfd1, dfd2: dfd1.merge(dfd2), log_tabs.values() ) + # skip plotting for intermediate step when + # returning to Q0 + if self.return_to_Q0 and self.intermediate_Q is None: + return new_log + + # Plot plot_pdf( rotate_to_pm_basis(new_log, skip="minus") - if self.rotate_to_evolution_basis + if not self.rotate_to_evolution_basis else new_log, self.fig_name, cl=1, From 267949dd0343b2eb1ac390102b0823c35a9b0ddd Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 22 Jul 2021 11:42:29 +0200 Subject: [PATCH 24/71] Fix ome talbot path and more tests --- .../operator_matrix_element.py | 4 +- tests/test_ev_operator.py | 2 +- tests/test_ome.py | 101 +++++++++++++----- 3 files changed, 76 insertions(+), 31 deletions(-) diff --git a/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index 19aa3e833..b2034fa84 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -168,7 +168,9 @@ def quad_ker(u, order, mode, is_log, logx, areas, a_s, L, backward_method): """ is_singlet = mode[0] == "S" # get transformation to N integral - r = 0.4 * 16.0 / (1.0 - logx) + if logx == 0: + return 0.0 + r = 0.4 * 16.0 / (- logx) if is_singlet: o = 1.0 indeces = {"g": 0, "q": 1, "H": 2} diff --git a/tests/test_ev_operator.py b/tests/test_ev_operator.py index 5bdc5efc7..bc053447d 100644 --- a/tests/test_ev_operator.py +++ b/tests/test_ev_operator.py @@ -169,7 +169,7 @@ def test_compute(self, monkeypatch): "interpolation_xgrid": [0.1, 1.0], "interpolation_polynomial_degree": 1, "interpolation_is_log": True, - "debug_skip_singlet": True, + "debug_skip_singlet": False, "debug_skip_non_singlet": False, "ev_op_max_order": 1, "ev_op_iterations": 1, diff --git a/tests/test_ome.py b/tests/test_ome.py index b4a300e5b..f90ec6720 100644 --- a/tests/test_ome.py +++ b/tests/test_ome.py @@ -90,7 +90,7 @@ def test_quad_ker(monkeypatch): order=2, mode="NS_qq", is_log=is_log, - logx=0.0, + logx=1.0, areas=np.zeros(3), backward_method=None, a_s=0.0, @@ -102,7 +102,7 @@ def test_quad_ker(monkeypatch): order=2, mode="S_qq", is_log=is_log, - logx=0.0, + logx=1.0, areas=np.zeros(3), backward_method=None, a_s=0.0, @@ -130,7 +130,7 @@ def test_quad_ker(monkeypatch): order=2, mode=label, is_log=True, - logx=0.0, + logx=1.0, areas=np.zeros(3), backward_method="expanded", a_s=0.0, @@ -160,7 +160,7 @@ def test_quad_ker(monkeypatch): order=2, mode=label, is_log=True, - logx=0.0, + logx=1.0, areas=np.zeros(3), backward_method="exact", a_s=0.0, @@ -187,28 +187,29 @@ def test_quad_ker(monkeypatch): class TestOperatorMatrixElement: + # setup objs + theory_card = { + "alphas": 0.35, + "PTO": 0, + "ModEv": "TRN", + "fact_to_ren_scale_ratio": 1.0, + "Qref": np.sqrt(2), + "nfref": None, + "Q0": np.sqrt(2), + "NfFF": 3, + "IC": 1, + "IB": 0, + "mc": 1.0, + "mb": 4.75, + "mt": 173.0, + "kcThr": np.inf, + "kbThr": np.inf, + "ktThr": np.inf, + "MaxNfPdf": 6, + "MaxNfAs": 6, + } + def test_labels(self): - # setup objs - theory_card = { - "alphas": 0.35, - "PTO": 0, - "ModEv": "TRN", - "fact_to_ren_scale_ratio": 1.0, - "Qref": np.sqrt(2), - "nfref": None, - "Q0": np.sqrt(2), - "NfFF": 3, - "IC": 1, - "IB": 0, - "mc": 1.0, - "mb": 4.75, - "mt": 173.0, - "kcThr": np.inf, - "kbThr": np.inf, - "ktThr": np.inf, - "MaxNfPdf": 6, - "MaxNfAs": 6, - } for skip_singlet in [True, False]: for skip_ns in [True, False]: operators_card = { @@ -223,13 +224,13 @@ def test_labels(self): "backward_inversion": "exact", } g = OperatorGrid.from_dict( - theory_card, + self.theory_card, operators_card, - ThresholdsAtlas.from_dict(theory_card), - StrongCoupling.from_dict(theory_card), + ThresholdsAtlas.from_dict(self.theory_card), + StrongCoupling.from_dict(self.theory_card), InterpolatorDispatcher.from_dict(operators_card), ) - o = OperatorMatrixElement(g.config, g.managers, 10) + o = OperatorMatrixElement(g.config, g.managers, is_backward=False) labels = o.labels() test_labels = ["NS_qq", "NS_Hq"] for l in test_labels: @@ -243,3 +244,45 @@ def test_labels(self): assert l not in labels else: assert l in labels + + def test_compute(self): + operators_card = { + "Q2grid": [20], + "interpolation_xgrid": [0.001, 0.01, 0.1, 1.0], + "interpolation_polynomial_degree": 1, + "interpolation_is_log": True, + "debug_skip_singlet": False, + "debug_skip_non_singlet": False, + "ev_op_max_order": 1, + "ev_op_iterations": 1, + "backward_inversion": "exact", + } + g = OperatorGrid.from_dict( + self.theory_card, + operators_card, + ThresholdsAtlas.from_dict(self.theory_card), + StrongCoupling.from_dict(self.theory_card), + InterpolatorDispatcher.from_dict(operators_card), + ) + o = OperatorMatrixElement(g.config, g.managers, is_backward=False) + o.compute(self.theory_card["mb"] ** 2, L=0) + + dim = o.ome_members[f"NS_qq"].value.shape + for idx in ["S", "NS"]: + np.testing.assert_allclose( + o.ome_members[f"{idx}_qq"].value, np.eye(dim[0]), atol=1e-11 + ) + np.testing.assert_allclose( + o.ome_members[f"{idx}_HH"].value, np.eye(dim[0]), atol=1e-11 + ) + np.testing.assert_allclose(o.ome_members[f"{idx}_qH"].value, np.zeros(dim)) + np.testing.assert_allclose(o.ome_members[f"{idx}_Hq"].value, np.zeros(dim)) + np.testing.assert_allclose( + o.ome_members["S_gg"].value, np.eye(dim[0]), atol=1e-11 + ) + np.testing.assert_allclose( + o.ome_members["S_qg"].value, o.ome_members["S_gq"].value + ) + np.testing.assert_allclose( + o.ome_members["S_Hg"].value, o.ome_members["S_gH"].value + ) From 49d46d5405d5e4322371818d7882a48b94c87147 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Fri, 23 Jul 2021 12:24:44 +0200 Subject: [PATCH 25/71] improve navigator lagend --- backward_paper/navigator.py | 78 +++++++++++++++++++++++++------------ backward_paper/plots.py | 7 ++-- 2 files changed, 58 insertions(+), 27 deletions(-) diff --git a/backward_paper/navigator.py b/backward_paper/navigator.py index 51f391e0f..183b09aac 100644 --- a/backward_paper/navigator.py +++ b/backward_paper/navigator.py @@ -18,6 +18,10 @@ from plots import plot_pdf +def replace_label(new_label): + return lambda s: s.replace("EKO", f"{new_label}") + + class NavigatorApp(Ekonavigator): """ Specialization of the Ekomark navigator. @@ -46,10 +50,44 @@ def get_replica(tab, n): ngrid = int(len(tab) / nrep) return tab.iloc[n * ngrid : (n + 1) * ngrid, :] + def search_label(self, log, key): + """ + Search the label to display + + Parameters + ---------- + log : dict + log dictionary + key : str + key of which value will be used as label + + Returns + ------- + label: str + value to use in the legend + """ + if key == "pdf": + label = log["pdf"] + elif key is not None: + try: + theory = self.get(bnav.t, log["t_hash"]) + label = theory[key] + except KeyError: + try: + operators = self.get(bnav.o, log["o_hash"]) + label = operators[key] + except KeyError as err: + raise KeyError( + f"{key} is neither in operator card neither in theory card" + ) from err + else: + label = "EKO" + return label + def plot_logs( self, hashes, - key_to_plot=None, + label_to_display=None, rotate_to_pm_basis=True, skip=None, plot_pull=False, @@ -62,7 +100,7 @@ def plot_logs( ---------- hashes : list log hash list to plot - key_to_plot: str + label_to_display: str key to display in the plot legend: 'pdf' or theory/operator key rotate_to_pm_basis : bool if True rotate to plus minus basis @@ -77,24 +115,9 @@ def plot_logs( log = self.get(bnav.l, h) dfds.append(log["log"]) fig_name += f"{log['hash'][: self.hash_len]}_" - # search the label - if key_to_plot == "pdf": - labels.append(log["pdf"]) - elif key_to_plot is not None: - try: - theory = self.get(bnav.t, log["t_hash"]) - labels.append(theory[key_to_plot]) - except KeyError: - try: - operators = self.get(bnav.o, log["o_hash"]) - labels.append(operators[key_to_plot]) - except KeyError as err: - raise KeyError( - f"{key_to_plot} is neither in operator card neither in theory card" - ) from err - else: - labels.append("EKO") + labels.append(self.search_label(log, label_to_display)) + # build a total log table with new keys fig_name = fig_name[:-1] total_log = dfdict.DFdict() @@ -102,8 +125,8 @@ def plot_logs( for pid, tab in dfd.items(): # set first table if n == 0: - total_log[pid] = pd.DataFrame( - {k.replace("EKO", f"{labels[n]}"): v for k, v in tab.items()} + total_log[pid] = pd.DataFrame(tab).rename( + columns=replace_label(labels[n]) ) # set the other tables else: @@ -119,7 +142,9 @@ def plot_logs( plot_pull=plot_pull, ) - def compute_momentum_fraction(self, hashes, rotate_to_pm_basis=True, skip=None): + def compute_momentum_fraction( + self, hashes, label_to_display=None, rotate_to_pm_basis=True, skip=None + ): """ Compute the momentum fraction for each PDF @@ -127,6 +152,8 @@ def compute_momentum_fraction(self, hashes, rotate_to_pm_basis=True, skip=None): ---------- hashes : list log hash list to plot + label_to_display: str + key to display in the plot legend: 'pdf' or theory/operator key rotate_to_pm_basis : bool if True rotate to plus minus basis skip : str @@ -153,15 +180,18 @@ def integrand(delta_x): integrand(replica_tab.x) ) mom_df = mom_df.append(pd.DataFrame(replica_mom).T) - # average and std + + # average and std and rename if necessary momentum_log[pid] = pd.concat( [ mom_df.mean().rename("momentum fraction"), mom_df.std().rename("std"), mom_df.mean().rename("momentum fraction (%)") * 100, + mom_df.mean().div(mom_df.std()).rename("Evidence"), ], axis=1, - ) + ).rename(index=replace_label(self.search_label(log, label_to_display))) + print("Log:", log["hash"]) print(momentum_log) diff --git a/backward_paper/plots.py b/backward_paper/plots.py index 6609d7ef8..647e8a862 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -7,7 +7,6 @@ from matplotlib import use, rc from matplotlib.backends.backend_pdf import PdfPages import matplotlib.pyplot as plt -import pandas as pd from config import pkg_path @@ -103,7 +102,7 @@ def plot_pdf(log, fig_name, cl=1, plot_pull=False, plot_reldiff=False): np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5 ) ax_ratio.set_xlabel(r"\rm{x}") - ax_ratio.set_ylabel(r"\rm{Pull}", fontsize=11) + ax_ratio.set_ylabel(r"\rm{Evidence}", fontsize=11) elif plot_reldiff: ax_ratio = plt.subplot(gs[-1:, ncol], sharex=ax) ref_data = mean.iloc[:, 1] @@ -112,7 +111,9 @@ def plot_pdf(log, fig_name, cl=1, plot_pull=False, plot_reldiff=False): mean.x, (column_data - ref_data).div(ref_data).replace(np.nan, 0) * 100, - color=plt.rcParams['axes.prop_cycle'].by_key()['color'][idx+1], + color=plt.rcParams["axes.prop_cycle"].by_key()["color"][ + idx + 1 + ], ) ax_ratio.plot( np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5 From 6b1c34c8d0963db79f671d65e68bcac2259998e9 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Fri, 23 Jul 2021 12:25:33 +0200 Subject: [PATCH 26/71] separate run back and forth from run --- backward_paper/runner.py | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/backward_paper/runner.py b/backward_paper/runner.py index 2ed7c497d..c4256eae1 100644 --- a/backward_paper/runner.py +++ b/backward_paper/runner.py @@ -71,17 +71,15 @@ def __init__(self): self.ekos = [] self.intermediate_Q = None - def run(self, theory_updates, ocard_updates, pdfs, use_replicas=False): - if self.return_to_Q0: - # prevent to run all the possible runcards combinations - # but only the sequence: q0->q1->q0 - self.ekos = [] - for idx, q0 in enumerate(theory_updates[0]["Q0"]): - temp_theory = copy.deepcopy(theory_updates) - temp_theory[0]["Q0"] = q0 - super().run(temp_theory, [ocard_updates[idx]], pdfs, use_replicas) - else: - super().run(theory_updates, ocard_updates, pdfs, use_replicas) + def run_back_forth(self, theory_updates, ocard_updates, pdfs, use_replicas=True): + """Compute the sequence q0->q1->q0""" + self.ekos = [] + for idx, q0 in enumerate(theory_updates[0]["Q0"]): + temp_theory = copy.deepcopy(theory_updates) + temp_theory[0]["Q0"] = q0 + super().run( + temp_theory, [ocard_updates[idx]], pdfs, use_replicas=use_replicas + ) def run_me(self, theory, ocard, _pdf): # need to run or do an eko product? @@ -91,7 +89,7 @@ def run_me(self, theory, ocard, _pdf): if self.return_to_Q0: self.ekos.append(me) else: - self.console.print("Computing product between the prevoius Ekos") + self.console.print("Computing product between the previous Ekos") # get the operator tensors op_list = [] From eb1dc12cd4194ba3745ad67d848cd93ebb1e3948 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Fri, 23 Jul 2021 12:36:41 +0200 Subject: [PATCH 27/71] update backward runner and syntax fix --- backward_paper/evolve_backward.py | 53 +++++++++++++++++-------------- tests/benchmark_evol_to_unity.py | 4 +-- tests/test_ome.py | 2 +- 3 files changed, 33 insertions(+), 26 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index a58260513..2c30883ef 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -5,7 +5,7 @@ import numpy as np from ekomark.data import operators -from eko.interpolation import make_grid +#from eko.interpolation import make_grid, make_lambert_grid from runner import BackwardPaperRunner @@ -29,15 +29,18 @@ class BackwardRunner(BackwardPaperRunner): "kcThr": 1.0, "kbThr": 1.0, "ktThr": 1.0, - "PTO": 2, + "PTO": 1, "IC": 1, "IB": 1, + "ModEv": "EXA", } base_operator = { - # "interpolation_xgrid": [np.linspace(1e-1,1,50)], - # "interpolation_xgrid": [make_grid(30,30, x_min=1e-3).tolist()], - # "interpolation_polynomial_degree": 1, - "backward_inversion": ["exact"] # ["expanded","exact"], + # "interpolation_xgrid": [np.linspace(1e-2,1,50)], + # "interpolation_xgrid": [make_grid(30,10).tolist()], + # "interpolation_xgrid": [make_lambert_grid(50).tolist()], + # "interpolation_polynomial_degree": [1], + "backward_inversion": ["exact"], + # "ev_op_iterations": [1], } def doit( @@ -77,19 +80,23 @@ def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5, return_to_Q0=False): """ operator_updates = self.base_operator.copy() theory_updates = self.base_theory.copy() + self.fig_name = None if return_to_Q0: self.return_to_Q0 = return_to_Q0 self.fig_name = f"back_forth_{pdf_name}_{q_low}_{q_high}_{operator_updates['backward_inversion'][0]}" theory_updates["IC"] = 1 theory_updates["IB"] = 1 - self.rotate_to_evolution_basis = True - self.plot_pdfs = ["S", "g", "V"] - #self.plot_pdfs = [21, -5, 5] - # self.plot_pdfs = [21, -4, 4] + # self.rotate_to_evolution_basis = True + # self.plot_pdfs = ["S", "g", "V"] + # self.plot_pdfs = [21, -5, 5] operator_updates["Q2grid"] = [[q_low ** 2], [q_high ** 2], [q_high ** 2]] theory_updates["Q0"] = [q_high, q_low, q_high] - return self.doit(pdf_name, operator_updates, theory_updates) + return self.run_back_forth( + [theory_updates], + operators.build((operator_updates)), + [pdf_name], + ) return self.doit(pdf_name, operator_updates, theory_updates, q_high, q_low) @@ -135,30 +142,30 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): # Evolve below c threshold pdf_names = [ "210629-n3fit-001", # NNLO, fitted charm - # "210629-theory-003", # NNLO, perturbative charm + "210629-theory-003", # NNLO, perturbative charm # "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c # "NNPDF31_nnlo_pch_as_0118" ] - # for name in pdf_names: + for name in pdf_names: - # # # Simple inversion - # # myrunner.evolve_backward(name) + # Simple inversion + myrunner.evolve_backward(name) - # # # Test beclow above thr + # # Test beclow above thr # myrunner.evolve_above_below_thr(name) # # # Test exapanded/exact # # myrunner.evolve_exact_expanded(name) # # Test perturbarive B - pdf_name = "210629-n3fit-001" - # pdf_name = "ToyLH" + # pdf_name = "210629-n3fit-001" # myrunner.evolve_above_below_thr(pdf_name, q_high=5, heavy_quark="b") - # myrunner.evolve_backward(pdf_name, q_low=5, q_high=4.91, return_to_Q0=True) - # myrunner.evolve_backward(pdf_name, q_low=4.91, q_high=5, return_to_Q0=True) # # Test EKO back and forth - myrunner.evolve_backward(pdf_name, q_high=5, q_low=30, return_to_Q0=True) + # myrunner.evolve_backward(pdf_name, q_high=5, q_low=30, return_to_Q0=True) + # myrunner.evolve_backward(pdf_name, q_low=5, q_high=4.91, return_to_Q0=True) + # myrunner.evolve_backward(pdf_name, q_low=4.91, q_high=5, return_to_Q0=True) - # opposite not making sense, pdf at 1.5 is not defined - #myrunner.evolve_backward(pdf_name, q_low=1.5, q_high=1.65, return_to_Q0=True) + # you can't use n3fit-001 here since it's not defined below the thr scale + # pdf_name = "210629-theory-003" + # myrunner.evolve_backward(pdf_name, q_low=1.65, q_high=1.5, return_to_Q0=True) diff --git a/tests/benchmark_evol_to_unity.py b/tests/benchmark_evol_to_unity.py index 242131fe5..0c3229ad1 100644 --- a/tests/benchmark_evol_to_unity.py +++ b/tests/benchmark_evol_to_unity.py @@ -4,10 +4,10 @@ from eko.evolution_operator import Operator from eko.evolution_operator.grid import OperatorGrid -from eko.interpolation import InterpolatorDispatcher, make_grid +from eko.interpolation import InterpolatorDispatcher from eko.strong_coupling import StrongCoupling from eko.thresholds import ThresholdsAtlas -from eko.matching_conditions.operator_matrix_element import OperatorMatrixElement +#from eko.matching_conditions.operator_matrix_element import OperatorMatrixElement class TestBackwardForward: diff --git a/tests/test_ome.py b/tests/test_ome.py index f90ec6720..ddada98ef 100644 --- a/tests/test_ome.py +++ b/tests/test_ome.py @@ -267,7 +267,7 @@ def test_compute(self): o = OperatorMatrixElement(g.config, g.managers, is_backward=False) o.compute(self.theory_card["mb"] ** 2, L=0) - dim = o.ome_members[f"NS_qq"].value.shape + dim = o.ome_members["NS_qq"].value.shape for idx in ["S", "NS"]: np.testing.assert_allclose( o.ome_members[f"{idx}_qq"].value, np.eye(dim[0]), atol=1e-11 From 429c58eae9bba0d90f22464972f6b3f01ef99a45 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Fri, 23 Jul 2021 17:24:20 +0200 Subject: [PATCH 28/71] improve legends --- backward_paper/evolve_backward.py | 2 +- backward_paper/navigator.py | 7 +++++-- backward_paper/plots.py | 2 -- backward_paper/runner.py | 8 ++++---- 4 files changed, 10 insertions(+), 9 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 2c30883ef..f65d0bca6 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -29,7 +29,7 @@ class BackwardRunner(BackwardPaperRunner): "kcThr": 1.0, "kbThr": 1.0, "ktThr": 1.0, - "PTO": 1, + "PTO": 2, "IC": 1, "IB": 1, "ModEv": "EXA", diff --git a/backward_paper/navigator.py b/backward_paper/navigator.py index 183b09aac..5542438eb 100644 --- a/backward_paper/navigator.py +++ b/backward_paper/navigator.py @@ -72,6 +72,9 @@ def search_label(self, log, key): try: theory = self.get(bnav.t, log["t_hash"]) label = theory[key] + if key == "PTO": + pto_dict = {0: "LO", 1: "NLO", 2: "NNLO"} + label = pto_dict[label] except KeyError: try: operators = self.get(bnav.o, log["o_hash"]) @@ -105,7 +108,7 @@ def plot_logs( rotate_to_pm_basis : bool if True rotate to plus minus basis skip : str - skip 'plus' or 'minus' distribution + skip '+' or '-' distribution """ dfds = [] @@ -157,7 +160,7 @@ def compute_momentum_fraction( rotate_to_pm_basis : bool if True rotate to plus minus basis skip : str - skip 'plus' or 'minus' distribution + skip '+' or '-' distribution """ def integrand(delta_x): diff --git a/backward_paper/plots.py b/backward_paper/plots.py index 647e8a862..a8d0e8d4c 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -19,8 +19,6 @@ def quark_latex_name(name): quark_name = name if "bar" in name: quark_name = r"$\bar{%s}$" % name[0] - quark_name = quark_name.replace("plus", "+") - quark_name = quark_name.replace("minus", "-") return quark_name diff --git a/backward_paper/runner.py b/backward_paper/runner.py index c4256eae1..c3b9e7f5c 100644 --- a/backward_paper/runner.py +++ b/backward_paper/runner.py @@ -30,11 +30,11 @@ def rotate_to_pm_basis(log, skip=None): log: dict log table skip: str - skip 'plus' or 'minus' + skip '+' or '-' """ rot_log = {} skip = skip if skip is not None else [] - if "g" in log: + if "g" in log and "g" not in skip: rot_log["g"] = log["g"] for pid in eko.evolution_operator.flavors.quark_names: if pid not in log: @@ -42,8 +42,8 @@ def rotate_to_pm_basis(log, skip=None): quark = log[pid] qbar = log[f"{pid}bar"].copy() - for key, fact in zip(["plus", "minus"], [1, -1]): - if key == skip: + for key, fact in zip(["+", "-"], [1, -1]): + if key in skip: continue rot_log[r"${%s}^{%s}$" % (pid, key)] = copy.deepcopy(quark) for column_name in quark.iloc[:, 1:]: From dc77aad20f5fd39eed294de9f7cf1900c3537430 Mon Sep 17 00:00:00 2001 From: Felix Hekhorn Date: Thu, 26 Aug 2021 17:56:16 +0200 Subject: [PATCH 29/71] Add alphas to output, relax some numerical tests, black --- src/eko/evolution_operator/__init__.py | 6 +++--- src/eko/evolution_operator/grid.py | 6 +++++- .../matching_conditions/operator_matrix_element.py | 2 +- src/eko/output.py | 9 +++++++-- tests/benchmark_evol_to_unity.py | 7 ++++--- tests/test_ev_op_grid.py | 14 ++++++++++++++ tests/test_ome.py | 6 +++--- tests/test_output.py | 1 + 8 files changed, 38 insertions(+), 13 deletions(-) diff --git a/src/eko/evolution_operator/__init__.py b/src/eko/evolution_operator/__init__.py index 1cdb7f1e3..568f95a8f 100644 --- a/src/eko/evolution_operator/__init__.py +++ b/src/eko/evolution_operator/__init__.py @@ -154,7 +154,7 @@ def quad_ker( # get transformation to N integral if logx == 0.0: return 0.0 - r = 0.4 * 16.0 / (- logx) + r = 0.4 * 16.0 / (-logx) if is_singlet: o = 1.0 else: @@ -262,8 +262,8 @@ def compute(self): # init all ops with identity or zeros if we skip them labels = self.labels() - eye = OpMember( np.eye(grid_size), np.zeros((grid_size, grid_size))) - zero = OpMember(*[np.zeros((grid_size, grid_size))] * 2 ) + eye = OpMember(np.eye(grid_size), np.zeros((grid_size, grid_size))) + zero = OpMember(*[np.zeros((grid_size, grid_size))] * 2) for n in full_labels: if n in labels: # off diag singlet are zero diff --git a/src/eko/evolution_operator/grid.py b/src/eko/evolution_operator/grid.py index 341da11dd..b1c467a2d 100644 --- a/src/eko/evolution_operator/grid.py +++ b/src/eko/evolution_operator/grid.py @@ -277,4 +277,8 @@ def generate(self, q2): final_op = final_op @ rot @ matching @ phys_op values, errors = final_op.to_flavor_basis_tensor() - return {"operators": values, "operator_errors": errors} + return { + "operators": values, + "operator_errors": errors, + "alphas": self.managers["strong_coupling"].a_s(q2) * 4.0 * np.pi, + } diff --git a/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index b2034fa84..2b6ba9666 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -170,7 +170,7 @@ def quad_ker(u, order, mode, is_log, logx, areas, a_s, L, backward_method): # get transformation to N integral if logx == 0: return 0.0 - r = 0.4 * 16.0 / (- logx) + r = 0.4 * 16.0 / (-logx) if is_singlet: o = 1.0 indeces = {"g": 0, "q": 1, "H": 2} diff --git a/src/eko/output.py b/src/eko/output.py index 4c0781f05..3ae330c65 100644 --- a/src/eko/output.py +++ b/src/eko/output.py @@ -5,9 +5,9 @@ import logging import warnings -import yaml import lz4.frame import numpy as np +import yaml from . import basis_rotation as br from . import interpolation @@ -284,6 +284,9 @@ def get_raw(self, binarize=True): for q2, op in self["Q2grid"].items(): out["Q2grid"][q2] = dict() for k, v in op.items(): + if k == "alphas": + out["Q2grid"][q2][k] = float(v) + continue if binarize: out["Q2grid"][q2][k] = lz4.frame.compress(v.tobytes()) else: @@ -357,7 +360,9 @@ def load_yaml(cls, stream): # make operators numpy for op in obj["Q2grid"].values(): for k, v in op.items(): - if isinstance(v, list): + if k == "alphas": + v = float(v) + elif isinstance(v, list): v = np.array(v) elif isinstance(v, bytes): v = np.frombuffer(lz4.frame.decompress(v)) diff --git a/tests/benchmark_evol_to_unity.py b/tests/benchmark_evol_to_unity.py index 0c3229ad1..1777477d3 100644 --- a/tests/benchmark_evol_to_unity.py +++ b/tests/benchmark_evol_to_unity.py @@ -7,7 +7,8 @@ from eko.interpolation import InterpolatorDispatcher from eko.strong_coupling import StrongCoupling from eko.thresholds import ThresholdsAtlas -#from eko.matching_conditions.operator_matrix_element import OperatorMatrixElement + +# from eko.matching_conditions.operator_matrix_element import OperatorMatrixElement class TestBackwardForward: @@ -34,8 +35,8 @@ class TestBackwardForward: operators_card = { "Q2grid": [10], # here you need a very dense grid - "interpolation_xgrid": np.linspace(1e-1,1,30), - #"interpolation_xgrid": make_grid(30,30, x_min=1e-3), + "interpolation_xgrid": np.linspace(1e-1, 1, 30), + # "interpolation_xgrid": make_grid(30,30, x_min=1e-3), "interpolation_polynomial_degree": 1, "interpolation_is_log": True, "debug_skip_singlet": False, diff --git a/tests/test_ev_op_grid.py b/tests/test_ev_op_grid.py index e5416b3e6..8e92930a8 100644 --- a/tests/test_ev_op_grid.py +++ b/tests/test_ev_op_grid.py @@ -101,8 +101,22 @@ def test_compute_q2grid(self): # we can also pass a single number opg = opgrid.compute() assert len(opg) == 2 + assert all( + [ + k in opg[q2] + for k in ["operators", "operator_errors", "alphas"] + for q2 in opg + ] + ) opg = opgrid.compute(3) assert len(opg) == 1 + assert all( + [ + k in opg[q2] + for k in ["operators", "operator_errors", "alphas"] + for q2 in opg + ] + ) def test_grid_computation_VFNS(self): """Checks that the grid can be computed""" diff --git a/tests/test_ome.py b/tests/test_ome.py index ddada98ef..fe81e8f85 100644 --- a/tests/test_ome.py +++ b/tests/test_ome.py @@ -270,15 +270,15 @@ def test_compute(self): dim = o.ome_members["NS_qq"].value.shape for idx in ["S", "NS"]: np.testing.assert_allclose( - o.ome_members[f"{idx}_qq"].value, np.eye(dim[0]), atol=1e-11 + o.ome_members[f"{idx}_qq"].value, np.eye(dim[0]), atol=1e-8 ) np.testing.assert_allclose( - o.ome_members[f"{idx}_HH"].value, np.eye(dim[0]), atol=1e-11 + o.ome_members[f"{idx}_HH"].value, np.eye(dim[0]), atol=1e-8 ) np.testing.assert_allclose(o.ome_members[f"{idx}_qH"].value, np.zeros(dim)) np.testing.assert_allclose(o.ome_members[f"{idx}_Hq"].value, np.zeros(dim)) np.testing.assert_allclose( - o.ome_members["S_gg"].value, np.eye(dim[0]), atol=1e-11 + o.ome_members["S_gg"].value, np.eye(dim[0]), atol=1e-8 ) np.testing.assert_allclose( o.ome_members["S_qg"].value, o.ome_members["S_gq"].value diff --git a/tests/test_output.py b/tests/test_output.py index fa963843b..1cf3b2f3e 100644 --- a/tests/test_output.py +++ b/tests/test_output.py @@ -37,6 +37,7 @@ def mk_g(self, q2s, lpids, lx): Q2grid[q2] = { "operators": np.random.rand(lpids, lx, lpids, lx), "operator_errors": np.random.rand(lpids, lx, lpids, lx), + "alphas": np.random.rand(), } return Q2grid From 117ecdb00adf7992c1272060c219759dd1a41fae Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Fri, 27 Aug 2021 09:22:59 +0200 Subject: [PATCH 30/71] restore mellin path for ome --- src/eko/matching_conditions/operator_matrix_element.py | 4 +--- tests/test_ome.py | 8 ++++---- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index 2b6ba9666..06906e614 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -168,9 +168,7 @@ def quad_ker(u, order, mode, is_log, logx, areas, a_s, L, backward_method): """ is_singlet = mode[0] == "S" # get transformation to N integral - if logx == 0: - return 0.0 - r = 0.4 * 16.0 / (-logx) + r = 0.4 * 16.0 / ( 1.0 - logx) if is_singlet: o = 1.0 indeces = {"g": 0, "q": 1, "H": 2} diff --git a/tests/test_ome.py b/tests/test_ome.py index fe81e8f85..4a33dbe02 100644 --- a/tests/test_ome.py +++ b/tests/test_ome.py @@ -90,7 +90,7 @@ def test_quad_ker(monkeypatch): order=2, mode="NS_qq", is_log=is_log, - logx=1.0, + logx=0.0, areas=np.zeros(3), backward_method=None, a_s=0.0, @@ -102,7 +102,7 @@ def test_quad_ker(monkeypatch): order=2, mode="S_qq", is_log=is_log, - logx=1.0, + logx=0.0, areas=np.zeros(3), backward_method=None, a_s=0.0, @@ -130,7 +130,7 @@ def test_quad_ker(monkeypatch): order=2, mode=label, is_log=True, - logx=1.0, + logx=0.0, areas=np.zeros(3), backward_method="expanded", a_s=0.0, @@ -160,7 +160,7 @@ def test_quad_ker(monkeypatch): order=2, mode=label, is_log=True, - logx=1.0, + logx=0.0, areas=np.zeros(3), backward_method="exact", a_s=0.0, From 691f7bc7dd2759c65d14818894936e82846997a3 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 23 Sep 2021 08:58:59 +0200 Subject: [PATCH 31/71] Init n3lo matching with various harmonics --- doc/source/refs.bib | 33 +- src/eko/anomalous_dimensions/harmonics.py | 30 +- src/eko/matching_conditions/n3lo/__init__.py | 41 + src/eko/matching_conditions/n3lo/aHg.py | 21 + src/eko/matching_conditions/n3lo/aHgstfac.py | 21 + src/eko/matching_conditions/n3lo/aHq.py | 21 + src/eko/matching_conditions/n3lo/agg.py | 21 + src/eko/matching_conditions/n3lo/agq.py | 21 + src/eko/matching_conditions/n3lo/aqg.py | 21 + src/eko/matching_conditions/n3lo/aqqNS.py | 21 + src/eko/matching_conditions/n3lo/aqqPS.py | 21 + .../matching_conditions/n3lo/f_functions.py | 8548 +++++++++++++++++ .../matching_conditions/n3lo/g_functions.py | 320 + .../matching_conditions/n3lo/s_functions.py | 71 + tests/test_f_functions.py | 142 + tests/test_g_functions.py | 129 + 16 files changed, 9480 insertions(+), 2 deletions(-) create mode 100644 src/eko/matching_conditions/n3lo/__init__.py create mode 100644 src/eko/matching_conditions/n3lo/aHg.py create mode 100644 src/eko/matching_conditions/n3lo/aHgstfac.py create mode 100644 src/eko/matching_conditions/n3lo/aHq.py create mode 100644 src/eko/matching_conditions/n3lo/agg.py create mode 100644 src/eko/matching_conditions/n3lo/agq.py create mode 100644 src/eko/matching_conditions/n3lo/aqg.py create mode 100644 src/eko/matching_conditions/n3lo/aqqNS.py create mode 100644 src/eko/matching_conditions/n3lo/aqqPS.py create mode 100644 src/eko/matching_conditions/n3lo/f_functions.py create mode 100644 src/eko/matching_conditions/n3lo/g_functions.py create mode 100644 src/eko/matching_conditions/n3lo/s_functions.py create mode 100644 tests/test_f_functions.py create mode 100644 tests/test_g_functions.py diff --git a/doc/source/refs.bib b/doc/source/refs.bib index d3a97d03e..8f327ea8b 100644 --- a/doc/source/refs.bib +++ b/doc/source/refs.bib @@ -370,4 +370,35 @@ @article{Carrazza_2020 publisher={Springer Science and Business Media LLC}, author={Carrazza, S. and Nocera, E. R. and Schwan, C. and Zaro, M.}, year={2020}, - month={Dec} \ No newline at end of file + month={Dec} +} + +@article{Bl_mlein_2000, + title={Analytic continuation of Mellin transforms up to two-loop order}, + volume={133}, + ISSN={0010-4655}, + url={http://dx.doi.org/10.1016/S0010-4655(00)00156-9}, + DOI={10.1016/s0010-4655(00)00156-9}, + number={1}, + journal={Computer Physics Communications}, + publisher={Elsevier BV}, + author={Blümlein, Johannes}, + year={2000}, + month={Dec}, + pages={76–104} +} + +@article{Bl_mlein_2009, + title={Structural relations of harmonic sums and Mellin transforms up to weight w=5}, + volume={180}, + ISSN={0010-4655}, + url={http://dx.doi.org/10.1016/j.cpc.2009.07.004}, + DOI={10.1016/j.cpc.2009.07.004}, + number={11}, + journal={Computer Physics Communications}, + publisher={Elsevier BV}, + author={Blümlein, Johannes}, + year={2009}, + month={Nov}, + pages={2218–2249} +} diff --git a/src/eko/anomalous_dimensions/harmonics.py b/src/eko/anomalous_dimensions/harmonics.py index fa16e0355..4526ab5fe 100644 --- a/src/eko/anomalous_dimensions/harmonics.py +++ b/src/eko/anomalous_dimensions/harmonics.py @@ -13,7 +13,7 @@ zeta2 = scipy.special.zeta(2) zeta3 = scipy.special.zeta(3) zeta4 = scipy.special.zeta(4) - +zeta5 = scipy.special.zeta(5) @nb.njit("c16(c16,u1)", cache=True) def cern_polygamma(Z, K: int): # pylint: disable=all @@ -244,6 +244,34 @@ def harmonic_S4(N): return zeta4 - 1.0 / 6.0 * cern_polygamma(N + 1.0, 3) +@nb.njit("c16(c16)", cache=True) +def harmonic_S5(N): + r""" + Computes the harmonic sum :math:`S_5(N)`. + + .. math:: + S_5(N) = \sum\limits_{j=1}^N \frac 1 {j^5} = \frac 1 24 \psi_4(N+1)+\zeta(5) + + with :math:`\psi_4(N)` the 4th-polygamma function and :math:`\zeta` the + Riemann zeta function. + + Parameters + ---------- + N : complex + Mellin moment + + Returns + ------- + S_5 : complex + Harmonic sum :math:`S_5(N)` + + See Also + -------- + cern_polygamma : :math:`\psi_k(N)` + """ + return zeta5 + 1.0 / 24.0 * cern_polygamma(N + 1.0, 4) + + @nb.njit("c16(c16)", cache=True) def mellin_g3(N): r""" diff --git a/src/eko/matching_conditions/n3lo/__init__.py b/src/eko/matching_conditions/n3lo/__init__.py new file mode 100644 index 000000000..7c6670c5b --- /dev/null +++ b/src/eko/matching_conditions/n3lo/__init__.py @@ -0,0 +1,41 @@ +# -*- coding: utf-8 -*- +""" +This module defines the matching conditions for the N3LO |VFNS| evolution. +""" +import numba as nb +import numpy as np + +from .agg import A_gg_3 +from .agq import A_gq_3 +from .aqg import A_qg_3 +from .aqqPS import A_qqPS_3 +from .aqqNS import A_qqNS_3 +from .aHg import A_Qg_3 +from .aHq import A_Qq_3 + + +@nb.njit("c16[:,:](c16,c16[:],u4,f8)", cache=True) +def A_singlet_3(n, sx, nf, L): + spx = sx[-5:] + A_hq = A_Qq_3(n, sx, spx, nf, L) + A_hg = A_Qg_3(n, sx, spx, nf, L) + + A_gq = A_gq_3(n, sx, spx, nf, L) + A_gg = A_gg_3(n, sx, spx, nf, L) + + A_qq_ps = A_qqPS_3(n, sx, spx, nf, L) + A_qq_ns = A_qqNS_3(n, sx, spx, nf, L) + A_qg = A_qg_3(n, sx, spx, nf, L) + + A_S_3 = np.array( + [[A_gg, A_gq, 0.0], [A_qg, A_qq_ps + A_qq_ns, 0.0], [A_hg, A_hq, 0.0]], + np.complex_, + ) + return A_S_3 + + +@nb.njit("c16[:,:](c16,c16[:],u4,f8)", cache=True) +def A_ns_3(n, sx, nf, L): + spx = sx[-5:] + A_qq = A_qqNS_3(n, sx, spx, nf, L) + return np.array([[A_qq, 0.0], [0 + 0j, 0 + 0j]], np.complex_) diff --git a/src/eko/matching_conditions/n3lo/aHg.py b/src/eko/matching_conditions/n3lo/aHg.py new file mode 100644 index 000000000..889f6cbfa --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aHg.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +import numba as nb +import numpy as np +from ...anomalous_dimensions import harmonics +from . import g_functions as gf + + +zeta2 = harmonics.zeta2 +zeta3 = harmonics.zeta3 +zeta4 = harmonics.zeta4 +zeta5 = harmonics.zeta5 +li4half = 0.517479 +li5half = 0.508401 + + +@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) +def A_Qg_3(n, sx, spx, nf, L): + S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] + Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] + return 0.0 diff --git a/src/eko/matching_conditions/n3lo/aHgstfac.py b/src/eko/matching_conditions/n3lo/aHgstfac.py new file mode 100644 index 000000000..9c273aaa7 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aHgstfac.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +import numba as nb +import numpy as np +from ...anomalous_dimensions import harmonics +from . import g_functions as gf + + +zeta2 = harmonics.zeta2 +zeta3 = harmonics.zeta3 +zeta4 = harmonics.zeta4 +zeta5 = harmonics.zeta5 +li4half = 0.517479 +li5half = 0.508401 + + +@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) +def A_Qgstfac_3(n, sx, spx, nf, L): + S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] + Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] + return 0.0 diff --git a/src/eko/matching_conditions/n3lo/aHq.py b/src/eko/matching_conditions/n3lo/aHq.py new file mode 100644 index 000000000..a7a738975 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aHq.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +import numba as nb +import numpy as np +from ...anomalous_dimensions import harmonics +from . import g_functions as gf + + +zeta2 = harmonics.zeta2 +zeta3 = harmonics.zeta3 +zeta4 = harmonics.zeta4 +zeta5 = harmonics.zeta5 +li4half = 0.517479 +li5half = 0.508401 + + +@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) +def A_Qq_3(n, sx, spx, nf, L): + S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] + Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] + return 0.0 diff --git a/src/eko/matching_conditions/n3lo/agg.py b/src/eko/matching_conditions/n3lo/agg.py new file mode 100644 index 000000000..160e14fe7 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/agg.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +import numba as nb +import numpy as np +from ...anomalous_dimensions import harmonics +from . import g_functions as gf + + +zeta2 = harmonics.zeta2 +zeta3 = harmonics.zeta3 +zeta4 = harmonics.zeta4 +zeta5 = harmonics.zeta5 +li4half = 0.517479 +li5half = 0.508401 + + +@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) +def A_gg_3(n, sx, spx, nf, L): + S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] + Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] + return 0.0 diff --git a/src/eko/matching_conditions/n3lo/agq.py b/src/eko/matching_conditions/n3lo/agq.py new file mode 100644 index 000000000..c295304de --- /dev/null +++ b/src/eko/matching_conditions/n3lo/agq.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +import numba as nb +import numpy as np +from ...anomalous_dimensions import harmonics +from . import g_functions as gf + + +zeta2 = harmonics.zeta2 +zeta3 = harmonics.zeta3 +zeta4 = harmonics.zeta4 +zeta5 = harmonics.zeta5 +li4half = 0.517479 +li5half = 0.508401 + + +@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) +def A_gq_3(n, sx, spx, nf, L): + S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] + Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] + return 0.0 diff --git a/src/eko/matching_conditions/n3lo/aqg.py b/src/eko/matching_conditions/n3lo/aqg.py new file mode 100644 index 000000000..caeb5d4b8 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aqg.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +import numba as nb +import numpy as np +from ...anomalous_dimensions import harmonics +from . import g_functions as gf + + +zeta2 = harmonics.zeta2 +zeta3 = harmonics.zeta3 +zeta4 = harmonics.zeta4 +zeta5 = harmonics.zeta5 +li4half = 0.517479 +li5half = 0.508401 + + +@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) +def A_qg_3(n, sx, spx, nf, L): + S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] + Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] + return 0.0 diff --git a/src/eko/matching_conditions/n3lo/aqqNS.py b/src/eko/matching_conditions/n3lo/aqqNS.py new file mode 100644 index 000000000..a3cca3ca6 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aqqNS.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +import numba as nb +import numpy as np +from ...anomalous_dimensions import harmonics +from . import g_functions as gf + + +zeta2 = harmonics.zeta2 +zeta3 = harmonics.zeta3 +zeta4 = harmonics.zeta4 +zeta5 = harmonics.zeta5 +li4half = 0.517479 +li5half = 0.508401 + + +@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) +def A_qqNS_3(n, sx, spx, nf, L): + S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] + Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] + return 0.0 diff --git a/src/eko/matching_conditions/n3lo/aqqPS.py b/src/eko/matching_conditions/n3lo/aqqPS.py new file mode 100644 index 000000000..9dbf4fbe0 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aqqPS.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +import numba as nb +import numpy as np +from ...anomalous_dimensions import harmonics +from . import g_functions as gf + + +zeta2 = harmonics.zeta2 +zeta3 = harmonics.zeta3 +zeta4 = harmonics.zeta4 +zeta5 = harmonics.zeta5 +li4half = 0.517479 +li5half = 0.508401 + + +@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) +def A_qqPS_3(n, sx, spx, nf, L): + S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] + Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] + return 0.0 diff --git a/src/eko/matching_conditions/n3lo/f_functions.py b/src/eko/matching_conditions/n3lo/f_functions.py new file mode 100644 index 000000000..b7b4f7be5 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/f_functions.py @@ -0,0 +1,8548 @@ +# -*- coding: utf-8 -*- +""" +This module contains some Mellin transfomations for 5th order harmonics sum. +Notation refers to :cite:`Bl_mlein_2009` +Mellin transform is defined with the convention x^(N) +""" +import numba as nb +import numpy as np + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def F17(n, S1, S2, S3): + return ( + 0.006250114775233491 * n + - (0.003746947390066303 * n) / (2.0 + n) + - (0.0023126098502258036 * n) / (3.0 + n) + + (0.0099367254968704 * n) / (4.0 + n) + + (0.011620487178071414 * n) / (5.0 + n) + - (0.06649377693249485 * n) / (6.0 + n) + + (0.19948261641123977 * n) / (7.0 + n) + - (0.4211429420070887 * n) / (8.0 + n) + + (0.6134519590989854 * n) / (9.0 + n) + - (0.6080710864181954 * n) / (10.0 + n) + + (0.39145233830114945 * n) / (11.0 + n) + - (0.1477783591293883 * n) / (12.0 + n) + + (0.02482853473316387 * n) / (13.0 + n) + + 0.007477407032205702 * (-1.0 + 1 / (1.0 + n)) + - 0.000051440329218106995 + * n + * ( + 121.50223994844418 + + 83580.0 / (1.0 + n) + - 3390.0 / (2.0 + n) + + 320.0 / (3.0 + n) + + (67770.0 * (1.0 + (1.0 + n) * S1)) / np.power(1.0 + n, 2) + - (5805.0 * (1.0 + (2.0 + n) * (1 / (1.0 + n) + S1))) / np.power(2.0 + n, 2) + + (720.0 * (1.0 + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1))) + / np.power(3.0 + n, 2) + - ( + 83725.36366334453 + * ( + 1.0 + + n + * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) + ) + ) + / np.power(n, 2) + - ( + 9180.0 + * ( + 1.0 + + (2.0 + n) * (1 / (1.0 + n) + S1) + + np.power(2.0 + n, 2) + * ( + np.power(1.0 + n, -2) + + S1 / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + ) + / np.power(2.0 + n, 3) + + ( + 52920.0 + * ( + 1.0 + + (1.0 + n) * S1 + + np.power(1.0 + n, 2) + * ( + np.power(1.0 + n, -2) + + S1 / (1.0 + n) + - (1.0 * (1 / (1.0 + n) + S1)) / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + ) + / np.power(1.0 + n, 3) + + ( + 1440.0 + * ( + 1.0 + + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + + np.power(3.0 + n, 2) + * ( + np.power(1.0 + n, -2) + + np.power(2.0 + n, -2) + + S1 / (1.0 + n) + + (1 / (1.0 + n) + S1) / (2.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + ) + / np.power(3.0 + n, 3) + - ( + 45180.0 + * ( + 1.0 + + n + * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) + + np.power(n, 2) + * ( + np.power(1.0 + n, -2) + + 1 / (n * (1.0 + n)) + + S1 / (1.0 + n) + + ((1.0 - 2.0 * (1.0 + n)) * (1 / (1.0 + n) + S1)) + / (n * (1.0 + n)) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + ) + / np.power(n, 3) + + ( + 11340.0 + * ( + -1.0 + - 1.0 * (2.0 + n) * (1 / (1.0 + n) + S1) + - 1.0 + * np.power(2.0 + n, 2) + * ( + np.power(1.0 + n, -2) + + S1 / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + - 1.0 + * np.power(2.0 + n, 3) + * ( + np.power(1.0 + n, -3) + + S1 / np.power(1.0 + n, 2) + + (0.5 * np.power(S1, 2)) / (1.0 + n) + + (0.5 * S2) / (1.0 + n) + + 0.16666666666666666 + * (np.power(S1, 3) + 3.0 * S1 * S2 + 2.0 * S3) + ) + ) + ) + / np.power(2.0 + n, 4) + + ( + 35640.0 + * ( + 1.0 + + (1.0 + n) * S1 + + np.power(1.0 + n, 2) + * ( + np.power(1.0 + n, -2) + + S1 / (1.0 + n) + - (1.0 * (1 / (1.0 + n) + S1)) / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + + np.power(1.0 + n, 3) + * ( + np.power(1.0 + n, -3) + + S1 / np.power(1.0 + n, 2) + + (0.5 * np.power(S1, 2)) / (1.0 + n) + - (0.5 * np.power(1 / (1.0 + n) + S1, 2)) / (1.0 + n) + + (0.5 * S2) / (1.0 + n) + - (0.5 * (np.power(1.0 + n, -2) + S2)) / (1.0 + n) + + 0.16666666666666666 + * (np.power(S1, 3) + 3.0 * S1 * S2 + 2.0 * S3) + ) + ) + ) + / np.power(1.0 + n, 4) + + ( + 2160.0 + * ( + 1.0 + + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + + np.power(3.0 + n, 2) + * ( + np.power(1.0 + n, -2) + + np.power(2.0 + n, -2) + + S1 / (1.0 + n) + + (1 / (1.0 + n) + S1) / (2.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + + np.power(3.0 + n, 3) + * ( + np.power(1.0 + n, -3) + + np.power(2.0 + n, -3) + + S1 / np.power(1.0 + n, 2) + + (0.5 * np.power(S1, 2)) / (1.0 + n) + + (1 / (1.0 + n) + S1) / np.power(2.0 + n, 2) + + (0.5 * np.power(1 / (1.0 + n) + S1, 2)) / (2.0 + n) + + (0.5 * S2) / (1.0 + n) + + (0.5 * (np.power(1.0 + n, -2) + S2)) / (2.0 + n) + + 0.16666666666666666 + * (np.power(S1, 3) + 3.0 * S1 * S2 + 2.0 * S3) + ) + ) + ) + / np.power(3.0 + n, 4) + + ( + 26460.0 + * ( + -1.0 + - 1.0 + * n + * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) + - 1.0 + * np.power(n, 2) + * ( + np.power(1.0 + n, -2) + + 1 / (n * (1.0 + n)) + + S1 / (1.0 + n) + + ((1.0 - 2.0 * (1.0 + n)) * (1 / (1.0 + n) + S1)) + / (n * (1.0 + n)) + + 0.5 * (np.power(S1, 2) + S2) + ) + - 1.0 + * np.power(n, 3) + * ( + np.power(1.0 + n, -3) + + S1 / np.power(1.0 + n, 2) + + (0.5 * np.power(S1, 2)) / (1.0 + n) + + (1 / (1.0 + n) + S1) / (n * (1.0 + n)) + + ( + 0.5 + * (1.0 - 2.0 * (1.0 + n)) + * np.power(1 / (1.0 + n) + S1, 2) + ) + / (n * (1.0 + n)) + + (0.5 * S2) / (1.0 + n) + + (0.5 * (1.0 - 2.0 * (1.0 + n)) * (np.power(1.0 + n, -2) + S2)) + / (n * (1.0 + n)) + + 0.16666666666666666 + * (np.power(S1, 3) + 3.0 * S1 * S2 + 2.0 * S3) + ) + ) + ) + / np.power(n, 4) + ) + ) + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def F14(n, S1, S2, S21): + return ( + 1.875523244753495 + + 0.49999902059348167 + * ( + 4.808227612638377 / (2.0 + n) + + (3.2898681336964524 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / (2.0 + n) + - ( + 4.0 + * ( + 0.5 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 2) + + 0.5 * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) + ) + ) + / np.power(2.0 + n, 2) + - ( + 2.0 + * ( + np.power(1.0 + n, -3) + + np.power(2.0 + n, -3) + + S1 / np.power(1.0 + n, 2) + + (1 / (1.0 + n) + S1) / np.power(2.0 + n, 2) + + S21 + ) + ) + / (2.0 + n) + + n + * ( + 6.0 / np.power(2.0 + n, 5) + - 3.2898681336964524 / np.power(2.0 + n, 3) + - 4.808227612638377 / np.power(2.0 + n, 2) + + 2.705808084277845 / (2.0 + n) + + (6.0 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 4) + - (3.2898681336964524 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 2) + + ( + 4.0 + * ( + 0.5 * np.power(1 / (1.0 + n) + S1, 2) + + 0.5 * (np.power(1.0 + n, -2) + S2) + ) + ) + / np.power(2.0 + n, 3) + + (2.0 * (np.power(1.0 + n, -3) + S1 / np.power(1.0 + n, 2) + S21)) + / np.power(2.0 + n, 2) + ) + ) + - 0.9999999952263307 + * ( + 4.808227612638377 / (1.0 + n) + + (3.2898681336964524 * (1 / (1.0 + n) + S1)) / (1.0 + n) + - ( + 4.0 + * ( + 0.5 * np.power(1 / (1.0 + n) + S1, 2) + + 0.5 * (np.power(1.0 + n, -2) + S2) + ) + ) + / np.power(1.0 + n, 2) + - (2.0 * (np.power(1.0 + n, -3) + S1 / np.power(1.0 + n, 2) + S21)) + / (1.0 + n) + + n + * ( + 6.0 / np.power(1.0 + n, 5) + - 3.2898681336964524 / np.power(1.0 + n, 3) + - 4.808227612638377 / np.power(1.0 + n, 2) + + 2.705808084277845 / (1.0 + n) + + (6.0 * S1) / np.power(1.0 + n, 4) + - (3.2898681336964524 * S1) / np.power(1.0 + n, 2) + + (4.0 * (0.5 * np.power(S1, 2) + 0.5 * S2)) / np.power(1.0 + n, 3) + + ( + 2.0 + * ( + np.power(1.0 + n, -3) + + S1 / np.power(1.0 + n, 2) + - (1.0 * (1 / (1.0 + n) + S1)) / np.power(1.0 + n, 2) + + S21 + ) + ) + / np.power(1.0 + n, 2) + ) + ) + - 0.3332995604546604 + * ( + 4.808227612638377 / (3.0 + n) + + ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + ) + / (3.0 + n) + - ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S2 + ) + ) + ) + / np.power(3.0 + n, 2) + - ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 11.0 + + 20.0 * (1.0 + n) + + 13.0 * np.power(1.0 + n, 2) + + 3.0 * np.power(1.0 + n, 3) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + S1 / np.power(1.0 + n, 2) + + ( + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + * (1 / (1.0 + n) + S1) + ) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S21 + ) + ) + / (3.0 + n) + + n + * ( + 6.0 / np.power(3.0 + n, 5) + - 3.2898681336964524 / np.power(3.0 + n, 3) + - 4.808227612638377 / np.power(3.0 + n, 2) + + 2.705808084277845 / (3.0 + n) + + (6.0 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / np.power(3.0 + n, 4) + - (3.2898681336964524 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) + / np.power(3.0 + n, 2) + + ( + 4.0 + * ( + 0.5 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 2) + + 0.5 * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) + ) + ) + / np.power(3.0 + n, 3) + + ( + 2.0 + * ( + np.power(1.0 + n, -3) + + np.power(2.0 + n, -3) + + S1 / np.power(1.0 + n, 2) + + (1 / (1.0 + n) + S1) / np.power(2.0 + n, 2) + + S21 + ) + ) + / np.power(3.0 + n, 2) + ) + ) + + 0.24954082848379078 + * ( + 4.808227612638377 / (4.0 + n) + + ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + ) + / (4.0 + n) + - ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(4.0 + n, 2) + - ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 341.0 + + 1017.0 * (1.0 + n) + + 1289.0 * np.power(1.0 + n, 2) + + 881.0 * np.power(1.0 + n, 3) + + 340.0 * np.power(1.0 + n, 4) + + 70.0 * np.power(1.0 + n, 5) + + 6.0 * np.power(1.0 + n, 6) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + S21 + ) + ) + / (4.0 + n) + + n + * ( + 6.0 / np.power(4.0 + n, 5) + - 3.2898681336964524 / np.power(4.0 + n, 3) + - 4.808227612638377 / np.power(4.0 + n, 2) + + 2.705808084277845 / (4.0 + n) + + ( + 6.0 + * ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + ) + / np.power(4.0 + n, 4) + - ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + ) + / np.power(4.0 + n, 2) + + ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S2 + ) + ) + ) + / np.power(4.0 + n, 3) + + ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 11.0 + + 20.0 * (1.0 + n) + + 13.0 * np.power(1.0 + n, 2) + + 3.0 * np.power(1.0 + n, 3) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + S1 / np.power(1.0 + n, 2) + + ( + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + * (1 / (1.0 + n) + S1) + ) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S21 + ) + ) + / np.power(4.0 + n, 2) + ) + ) + - 0.1967571967137462 + * ( + 4.808227612638377 / (5.0 + n) + + ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + ) + / (5.0 + n) + - ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(5.0 + n, 2) + - ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 23624.0 + + 90576.0 * (1.0 + n) + + 155374.0 * np.power(1.0 + n, 2) + + 155615.0 * np.power(1.0 + n, 3) + + 99831.0 * np.power(1.0 + n, 4) + + 42413.0 * np.power(1.0 + n, 5) + + 11911.0 * np.power(1.0 + n, 6) + + 2130.0 * np.power(1.0 + n, 7) + + 220.0 * np.power(1.0 + n, 8) + + 10.0 * np.power(1.0 + n, 9) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + S21 + ) + ) + / (5.0 + n) + + n + * ( + 6.0 / np.power(5.0 + n, 5) + - 3.2898681336964524 / np.power(5.0 + n, 3) + - 4.808227612638377 / np.power(5.0 + n, 2) + + 2.705808084277845 / (5.0 + n) + + ( + 6.0 + * ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + ) + / np.power(5.0 + n, 4) + - ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + ) + / np.power(5.0 + n, 2) + + ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(5.0 + n, 3) + + ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 341.0 + + 1017.0 * (1.0 + n) + + 1289.0 * np.power(1.0 + n, 2) + + 881.0 * np.power(1.0 + n, 3) + + 340.0 * np.power(1.0 + n, 4) + + 70.0 * np.power(1.0 + n, 5) + + 6.0 * np.power(1.0 + n, 6) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + S21 + ) + ) + / np.power(5.0 + n, 2) + ) + ) + + 0.1530503487172192 + * ( + 4.808227612638377 / (6.0 + n) + + ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 + ) + ) + / (6.0 + n) + - ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(6.0 + n, 2) + - ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 3.110824e6 + + 1.40106e7 * (1.0 + n) + + 2.894151e7 * np.power(1.0 + n, 2) + + 3.6105269e7 * np.power(1.0 + n, 3) + + 3.0197768e7 * np.power(1.0 + n, 4) + + 1.7798299e7 * np.power(1.0 + n, 5) + + 7.568825e6 * np.power(1.0 + n, 6) + + 2.337861e6 * np.power(1.0 + n, 7) + + 520317.0 * np.power(1.0 + n, 8) + + 81361.0 * np.power(1.0 + n, 9) + + 8485.0 * np.power(1.0 + n, 10) + + 530.0 * np.power(1.0 + n, 11) + + 15.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + S21 + ) + ) + / (6.0 + n) + + n + * ( + 6.0 / np.power(6.0 + n, 5) + - 3.2898681336964524 / np.power(6.0 + n, 3) + - 4.808227612638377 / np.power(6.0 + n, 2) + + 2.705808084277845 / (6.0 + n) + + ( + 6.0 + * ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + ) + / np.power(6.0 + n, 4) + - ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + ) + / np.power(6.0 + n, 2) + + ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(6.0 + n, 3) + + ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 23624.0 + + 90576.0 * (1.0 + n) + + 155374.0 * np.power(1.0 + n, 2) + + 155615.0 * np.power(1.0 + n, 3) + + 99831.0 * np.power(1.0 + n, 4) + + 42413.0 * np.power(1.0 + n, 5) + + 11911.0 * np.power(1.0 + n, 6) + + 2130.0 * np.power(1.0 + n, 7) + + 220.0 * np.power(1.0 + n, 8) + + 10.0 * np.power(1.0 + n, 9) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + S21 + ) + ) + / np.power(6.0 + n, 2) + ) + ) + - 0.10602798528818422 + * ( + 4.808227612638377 / (7.0 + n) + + ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + ) + / (7.0 + n) + - ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(7.0 + n, 2) + - ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 6.97339584e8 + + 3.525030432e9 * (1.0 + n) + + 8.293536336e9 * np.power(1.0 + n, 2) + + 1.2007529256e10 * np.power(1.0 + n, 3) + + 1.193375892e10 * np.power(1.0 + n, 4) + + 8.60864186e9 * np.power(1.0 + n, 5) + + 4.650892802e9 * np.power(1.0 + n, 6) + + 1.914862936e9 * np.power(1.0 + n, 7) + + 6.05522329e8 * np.power(1.0 + n, 8) + + 1.47044895e8 * np.power(1.0 + n, 9) + + 2.7198669e7 * np.power(1.0 + n, 10) + + 3.763711e6 * np.power(1.0 + n, 11) + + 377251.0 * np.power(1.0 + n, 12) + + 25865.0 * np.power(1.0 + n, 13) + + 1085.0 * np.power(1.0 + n, 14) + + 21.0 * np.power(1.0 + n, 15) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S21 + ) + ) + / (7.0 + n) + + n + * ( + 6.0 / np.power(7.0 + n, 5) + - 3.2898681336964524 / np.power(7.0 + n, 3) + - 4.808227612638377 / np.power(7.0 + n, 2) + + 2.705808084277845 / (7.0 + n) + + ( + 6.0 + * ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 + ) + ) + / np.power(7.0 + n, 4) + - ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 + ) + ) + / np.power(7.0 + n, 2) + + ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(7.0 + n, 3) + + ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 3.110824e6 + + 1.40106e7 * (1.0 + n) + + 2.894151e7 * np.power(1.0 + n, 2) + + 3.6105269e7 * np.power(1.0 + n, 3) + + 3.0197768e7 * np.power(1.0 + n, 4) + + 1.7798299e7 * np.power(1.0 + n, 5) + + 7.568825e6 * np.power(1.0 + n, 6) + + 2.337861e6 * np.power(1.0 + n, 7) + + 520317.0 * np.power(1.0 + n, 8) + + 81361.0 * np.power(1.0 + n, 9) + + 8485.0 * np.power(1.0 + n, 10) + + 530.0 * np.power(1.0 + n, 11) + + 15.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + S21 + ) + ) + / np.power(7.0 + n, 2) + ) + ) + + 0.056951717764149916 + * ( + 4.808227612638377 / (8.0 + n) + + ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + ) + / (8.0 + n) + - ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(8.0 + n, 2) + - ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 2.0 + * ( + 1.22980964256e11 + + 6.79202212752e11 * (1.0 + n) + + 1.762986212232e12 * np.power(1.0 + n, 2) + + 2.849976037428e12 * np.power(1.0 + n, 3) + + 3.208712317944e12 * np.power(1.0 + n, 4) + + 2.66793900071e12 * np.power(1.0 + n, 5) + + 1.696140569839e12 * np.power(1.0 + n, 6) + + 8.42534361945e11 * np.power(1.0 + n, 7) + + 3.31394293594e11 * np.power(1.0 + n, 8) + + 1.03973066426e11 * np.power(1.0 + n, 9) + + 2.6083138284e10 * np.power(1.0 + n, 10) + + 5.220244242e9 * np.power(1.0 + n, 11) + + 8.27501148e8 * np.power(1.0 + n, 12) + + 1.02512358e8 * np.power(1.0 + n, 13) + + 9.709175e6 * np.power(1.0 + n, 14) + + 678601.0 * np.power(1.0 + n, 15) + + 32970.0 * np.power(1.0 + n, 16) + + 994.0 * np.power(1.0 + n, 17) + + 14.0 * np.power(1.0 + n, 18) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S21 + ) + ) + / (8.0 + n) + + n + * ( + 6.0 / np.power(8.0 + n, 5) + - 3.2898681336964524 / np.power(8.0 + n, 3) + - 4.808227612638377 / np.power(8.0 + n, 2) + + 2.705808084277845 / (8.0 + n) + + ( + 6.0 + * ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + ) + / np.power(8.0 + n, 4) + - ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + ) + / np.power(8.0 + n, 2) + + ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(8.0 + n, 3) + + ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 6.97339584e8 + + 3.525030432e9 * (1.0 + n) + + 8.293536336e9 * np.power(1.0 + n, 2) + + 1.2007529256e10 * np.power(1.0 + n, 3) + + 1.193375892e10 * np.power(1.0 + n, 4) + + 8.60864186e9 * np.power(1.0 + n, 5) + + 4.650892802e9 * np.power(1.0 + n, 6) + + 1.914862936e9 * np.power(1.0 + n, 7) + + 6.05522329e8 * np.power(1.0 + n, 8) + + 1.47044895e8 * np.power(1.0 + n, 9) + + 2.7198669e7 * np.power(1.0 + n, 10) + + 3.763711e6 * np.power(1.0 + n, 11) + + 377251.0 * np.power(1.0 + n, 12) + + 25865.0 * np.power(1.0 + n, 13) + + 1085.0 * np.power(1.0 + n, 14) + + 21.0 * np.power(1.0 + n, 15) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S21 + ) + ) + / np.power(8.0 + n, 2) + ) + ) + - 0.019847559824380426 + * ( + 4.808227612638377 / (9.0 + n) + + ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + ) + / (9.0 + n) + - ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(9.0 + n, 2) + - ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 6.0 + * ( + 2.1452686055424e13 + + 1.27193972324352e14 * (1.0 + n) + + 3.569135825824e14 * np.power(1.0 + n, 2) + + 6.28964181904288e14 * np.power(1.0 + n, 3) + + 7.79557064653264e14 * np.power(1.0 + n, 4) + + 7.2173981400876e14 * np.power(1.0 + n, 5) + + 5.17717816384772e14 * np.power(1.0 + n, 6) + + 2.94648846212476e14 * np.power(1.0 + n, 7) + + 1.35183891860404e14 * np.power(1.0 + n, 8) + + 5.0528576648611e13 * np.power(1.0 + n, 9) + + 1.5487423206191e13 * np.power(1.0 + n, 10) + + 3.905253305568e12 * np.power(1.0 + n, 11) + + 8.10278287284e11 * np.power(1.0 + n, 12) + + 1.37943606892e11 * np.power(1.0 + n, 13) + + 1.9149259574e10 * np.power(1.0 + n, 14) + + 2.145327532e9 * np.power(1.0 + n, 15) + + 1.90913568e8 * np.power(1.0 + n, 16) + + 1.3175883e7 * np.power(1.0 + n, 17) + + 679567.0 * np.power(1.0 + n, 18) + + 24640.0 * np.power(1.0 + n, 19) + + 560.0 * np.power(1.0 + n, 20) + + 6.0 * np.power(1.0 + n, 21) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + S21 + ) + ) + / (9.0 + n) + + n + * ( + 6.0 / np.power(9.0 + n, 5) + - 3.2898681336964524 / np.power(9.0 + n, 3) + - 4.808227612638377 / np.power(9.0 + n, 2) + + 2.705808084277845 / (9.0 + n) + + ( + 6.0 + * ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + ) + / np.power(9.0 + n, 4) + - ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + ) + / np.power(9.0 + n, 2) + + ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(9.0 + n, 3) + + ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 2.0 + * ( + 1.22980964256e11 + + 6.79202212752e11 * (1.0 + n) + + 1.762986212232e12 * np.power(1.0 + n, 2) + + 2.849976037428e12 * np.power(1.0 + n, 3) + + 3.208712317944e12 * np.power(1.0 + n, 4) + + 2.66793900071e12 * np.power(1.0 + n, 5) + + 1.696140569839e12 * np.power(1.0 + n, 6) + + 8.42534361945e11 * np.power(1.0 + n, 7) + + 3.31394293594e11 * np.power(1.0 + n, 8) + + 1.03973066426e11 * np.power(1.0 + n, 9) + + 2.6083138284e10 * np.power(1.0 + n, 10) + + 5.220244242e9 * np.power(1.0 + n, 11) + + 8.27501148e8 * np.power(1.0 + n, 12) + + 1.02512358e8 * np.power(1.0 + n, 13) + + 9.709175e6 * np.power(1.0 + n, 14) + + 678601.0 * np.power(1.0 + n, 15) + + 32970.0 * np.power(1.0 + n, 16) + + 994.0 * np.power(1.0 + n, 17) + + 14.0 * np.power(1.0 + n, 18) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S21 + ) + ) + / np.power(9.0 + n, 2) + ) + ) + + 0.003243204652309423 + * ( + 4.808227612638377 / (10.0 + n) + + ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + ( + 3.0 + * ( + 342192.0 + + 781800.0 * (1.0 + n) + + 723680.0 * np.power(1.0 + n, 2) + + 359100.0 * np.power(1.0 + n, 3) + + 105455.0 * np.power(1.0 + n, 4) + + 18900.0 * np.power(1.0 + n, 5) + + 2030.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + ) + + S1 + ) + ) + / (10.0 + n) + - ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 3.0 + * ( + 342192.0 + + 781800.0 * (1.0 + n) + + 723680.0 * np.power(1.0 + n, 2) + + 359100.0 * np.power(1.0 + n, 3) + + 105455.0 * np.power(1.0 + n, 4) + + 18900.0 * np.power(1.0 + n, 5) + + 2030.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 3.0 + * ( + 6.7586510592e10 + + 2.7735912e11 * (1.0 + n) + + 5.25886236e11 * np.power(1.0 + n, 2) + + 6.098325648e11 * np.power(1.0 + n, 3) + + 4.8346372324e11 * np.power(1.0 + n, 4) + + 2.77716663e11 * np.power(1.0 + n, 5) + + 1.195744907e11 * np.power(1.0 + n, 6) + + 3.937668588e10 * np.power(1.0 + n, 7) + + 1.0027662147e10 * np.power(1.0 + n, 8) + + 1.982481e9 * np.power(1.0 + n, 9) + + 3.0344942e8 * np.power(1.0 + n, 10) + + 3.560508e7 * np.power(1.0 + n, 11) + + 3.141418e6 * np.power(1.0 + n, 12) + + 201600.0 * np.power(1.0 + n, 13) + + 8880.0 * np.power(1.0 + n, 14) + + 240.0 * np.power(1.0 + n, 15) + + 3.0 * np.power(1.0 + n, 16) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(10.0 + n, 2) + - ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 3.0 + * ( + 3.183431862446899e16 + + 2.001696918700032e17 * (1.0 + n) + + 5.98808681111543e17 * np.power(1.0 + n, 2) + + 1.1319310863695514e18 * np.power(1.0 + n, 3) + + 1.5156493142882596e18 * np.power(1.0 + n, 4) + + 1.5282976372182676e18 * np.power(1.0 + n, 5) + + 1.2049970049036114e18 * np.power(1.0 + n, 6) + + 7.616938706128154e17 * np.power(1.0 + n, 7) + + 3.92747201355673e17 * np.power(1.0 + n, 8) + + 1.6722252430665453e17 * np.power(1.0 + n, 9) + + 5.92988929379218e16 * np.power(1.0 + n, 10) + + 1.7614071211379864e16 * np.power(1.0 + n, 11) + + 4.397465867910487e15 * np.power(1.0 + n, 12) + + 9.23902782587314e14 * np.power(1.0 + n, 13) + + 1.6322843101295e14 * np.power(1.0 + n, 14) + + 2.4179602098084e13 * np.power(1.0 + n, 15) + + 2.987313035113e12 * np.power(1.0 + n, 16) + + 3.05296487914e11 * np.power(1.0 + n, 17) + + 2.550145462e10 * np.power(1.0 + n, 18) + + 1.711289424e9 * np.power(1.0 + n, 19) + + 8.9968697e7 * np.power(1.0 + n, 20) + + 3.567374e6 * np.power(1.0 + n, 21) + + 100270.0 * np.power(1.0 + n, 22) + + 1780.0 * np.power(1.0 + n, 23) + + 15.0 * np.power(1.0 + n, 24) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + * np.power(10.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + 3.0 + * ( + 6.7586510592e10 + + 2.7735912e11 * (1.0 + n) + + 5.25886236e11 * np.power(1.0 + n, 2) + + 6.098325648e11 * np.power(1.0 + n, 3) + + 4.8346372324e11 * np.power(1.0 + n, 4) + + 2.77716663e11 * np.power(1.0 + n, 5) + + 1.195744907e11 * np.power(1.0 + n, 6) + + 3.937668588e10 * np.power(1.0 + n, 7) + + 1.0027662147e10 * np.power(1.0 + n, 8) + + 1.982481e9 * np.power(1.0 + n, 9) + + 3.0344942e8 * np.power(1.0 + n, 10) + + 3.560508e7 * np.power(1.0 + n, 11) + + 3.141418e6 * np.power(1.0 + n, 12) + + 201600.0 * np.power(1.0 + n, 13) + + 8880.0 * np.power(1.0 + n, 14) + + 240.0 * np.power(1.0 + n, 15) + + 3.0 * np.power(1.0 + n, 16) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + ) + + S21 + ) + ) + / (10.0 + n) + + n + * ( + 6.0 / np.power(10.0 + n, 5) + - 3.2898681336964524 / np.power(10.0 + n, 3) + - 4.808227612638377 / np.power(10.0 + n, 2) + + 2.705808084277845 / (10.0 + n) + + ( + 6.0 + * ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + ) + / np.power(10.0 + n, 4) + - ( + 3.2898681336964524 + * ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + ) + / np.power(10.0 + n, 2) + + ( + 4.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(10.0 + n, 3) + + ( + 2.0 + * ( + np.power(1.0 + n, -3) + + ( + 6.0 + * ( + 2.1452686055424e13 + + 1.27193972324352e14 * (1.0 + n) + + 3.569135825824e14 * np.power(1.0 + n, 2) + + 6.28964181904288e14 * np.power(1.0 + n, 3) + + 7.79557064653264e14 * np.power(1.0 + n, 4) + + 7.2173981400876e14 * np.power(1.0 + n, 5) + + 5.17717816384772e14 * np.power(1.0 + n, 6) + + 2.94648846212476e14 * np.power(1.0 + n, 7) + + 1.35183891860404e14 * np.power(1.0 + n, 8) + + 5.0528576648611e13 * np.power(1.0 + n, 9) + + 1.5487423206191e13 * np.power(1.0 + n, 10) + + 3.905253305568e12 * np.power(1.0 + n, 11) + + 8.10278287284e11 * np.power(1.0 + n, 12) + + 1.37943606892e11 * np.power(1.0 + n, 13) + + 1.9149259574e10 * np.power(1.0 + n, 14) + + 2.145327532e9 * np.power(1.0 + n, 15) + + 1.90913568e8 * np.power(1.0 + n, 16) + + 1.3175883e7 * np.power(1.0 + n, 17) + + 679567.0 * np.power(1.0 + n, 18) + + 24640.0 * np.power(1.0 + n, 19) + + 560.0 * np.power(1.0 + n, 20) + + 6.0 * np.power(1.0 + n, 21) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + S21 + ) + ) + / np.power(10.0 + n, 2) + ) + ) + ) + + +@nb.njit("c16(c16,c16,c16)", cache=True) +def F11(n, S1, S2): + return ( + -0.1570209743051114 * n + - (0.4961137242141078 * n) / (2.0 + n) + + (0.14325154607236013 * n) / (3.0 + n) + + (0.043572446555835365 * n) / (4.0 + n) + - (0.1367619721729137 * n) / (5.0 + n) + + (0.5737638752229648 * n) / (6.0 + n) + - (1.6610332243741988 * n) / (7.0 + n) + + (3.333896376517311 * n) / (8.0 + n) + - (4.660416088583179 * n) / (9.0 + n) + + (4.454651830395971 * n) / (10.0 + n) + - (2.7814009672516686 * n) / (11.0 + n) + + (1.0238605215663694 * n) / (12.0 + n) + - (0.16899247190231767 * n) / (13.0 + n) + - 0.4887437258762844 * (-1.0 + 1 / (1.0 + n)) + - 1.0 + * n + * ( + -0.1570209813585035 + + 0.4166666666666667 / np.power(n, 3) + + 0.47941919157221546 / np.power(n, 2) + - 1.0 / np.power(1.0 + n, 3) + - 1.75 / np.power(1.0 + n, 2) + + 0.009326544681477866 / (1.0 + n) + + 0.75 / np.power(2.0 + n, 3) + + 1.25 / np.power(2.0 + n, 2) + + 0.8057445842680144 / (2.0 + n) + - 0.16666666666666666 / np.power(3.0 + n, 3) + - 0.25 / np.power(3.0 + n, 2) + - 0.13958627001930435 / (3.0 + n) + - (0.25 * (4.0 + 7.0 * (1.0 + n)) * S1) / np.power(1.0 + n, 2) + + (0.75 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 2) + + (1.25 * (1 / (1.0 + n) + S1)) / (2.0 + n) + - (0.16666666666666666 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) + / np.power(3.0 + n, 2) + - (0.25 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / (3.0 + n) + - ( + 0.002777777777777778 + * (22.59090896599757 - 172.59090896599758 * (1.0 + n)) + * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) + ) + / np.power(n, 2) + + ( + 0.75 + * ( + np.power(1.0 + n, -2) + + S1 / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + / (2.0 + n) + - ( + 1.0 + * ( + np.power(1.0 + n, -2) + + S1 / (1.0 + n) + - (1.0 * (1 / (1.0 + n) + S1)) / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + / (1.0 + n) + - ( + 0.16666666666666666 + * ( + np.power(1.0 + n, -2) + + np.power(2.0 + n, -2) + + S1 / (1.0 + n) + + (1 / (1.0 + n) + S1) / (2.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + / (3.0 + n) + + ( + 0.4166666666666667 + * ( + np.power(1.0 + n, -2) + + 1 / (n * (1.0 + n)) + + S1 / (1.0 + n) + + ((1.0 - 2.0 * (1.0 + n)) * (1 / (1.0 + n) + S1)) / (n * (1.0 + n)) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + / n + ) + ) + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def F18(n, S1, S2, S3): + return ( + 0.7502092979013981 + - 0.9999999952263307 + * ( + n + * ( + -1.0 / np.power(1.0 + n, 5) + + 1.0823232337111381 / (1.0 + n) + - (1.0 * S1) / np.power(1.0 + n, 4) + - (1.0 * (0.5 * np.power(S1, 2) + 0.5 * S2)) / np.power(1.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 * np.power(S1, 3) + + 0.5 * S1 * S2 + + 0.3333333333333333 * S3 + ) + ) + / np.power(1.0 + n, 2) + ) + + ( + 0.16666666666666666 * np.power(1 / (1.0 + n) + S1, 3) + + 0.5 * (1 / (1.0 + n) + S1) * (np.power(1.0 + n, -2) + S2) + + 0.3333333333333333 * (np.power(1.0 + n, -3) + S3) + ) + / (1.0 + n) + ) + + 0.49999902059348167 + * ( + ( + 0.16666666666666666 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 3) + + 0.5 + * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) + + 0.3333333333333333 + * (np.power(1.0 + n, -3) + np.power(2.0 + n, -3) + S3) + ) + / (2.0 + n) + + n + * ( + -1.0 / np.power(2.0 + n, 5) + + 1.0823232337111381 / (2.0 + n) + - (1.0 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 4) + - ( + 1.0 + * ( + 0.5 * np.power(1 / (1.0 + n) + S1, 2) + + 0.5 * (np.power(1.0 + n, -2) + S2) + ) + ) + / np.power(2.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 * np.power(1 / (1.0 + n) + S1, 3) + + 0.5 * (1 / (1.0 + n) + S1) * (np.power(1.0 + n, -2) + S2) + + 0.3333333333333333 * (np.power(1.0 + n, -3) + S3) + ) + ) + / np.power(2.0 + n, 2) + ) + ) + - 0.3332995604546604 + * ( + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + (3.0 + 2.0 * (1.0 + n)) + * (3.0 + 3.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + S3 + ) + ) + / (3.0 + n) + + n + * ( + -1.0 / np.power(3.0 + n, 5) + + 1.0823232337111381 / (3.0 + n) + - (1.0 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / np.power(3.0 + n, 4) + - ( + 1.0 + * ( + 0.5 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 2) + + 0.5 * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) + ) + ) + / np.power(3.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 + * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 3) + + 0.5 + * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) + + 0.3333333333333333 + * (np.power(1.0 + n, -3) + np.power(2.0 + n, -3) + S3) + ) + ) + / np.power(3.0 + n, 2) + ) + ) + + 0.24954082848379078 + * ( + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 251.0 + + 684.0 * (1.0 + n) + + 795.0 * np.power(1.0 + n, 2) + + 504.0 * np.power(1.0 + n, 3) + + 183.0 * np.power(1.0 + n, 4) + + 36.0 * np.power(1.0 + n, 5) + + 3.0 * np.power(1.0 + n, 6) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + + S3 + ) + ) + / (4.0 + n) + + n + * ( + -1.0 / np.power(4.0 + n, 5) + + 1.0823232337111381 / (4.0 + n) + - ( + 1.0 + * ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + ) + / np.power(4.0 + n, 4) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S2 + ) + ) + ) + / np.power(4.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + (3.0 + 2.0 * (1.0 + n)) + * (3.0 + 3.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + S3 + ) + ) + ) + / np.power(4.0 + n, 2) + ) + ) + - 0.1967571967137462 + * ( + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 1628.0 + + 5050.0 * (1.0 + n) + + 6935.0 * np.power(1.0 + n, 2) + + 5495.0 * np.power(1.0 + n, 3) + + 2737.0 * np.power(1.0 + n, 4) + + 875.0 * np.power(1.0 + n, 5) + + 175.0 * np.power(1.0 + n, 6) + + 20.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + S3 + ) + ) + / (5.0 + n) + + n + * ( + -1.0 / np.power(5.0 + n, 5) + + 1.0823232337111381 / (5.0 + n) + - ( + 1.0 + * ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + ) + / np.power(5.0 + n, 4) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(5.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 251.0 + + 684.0 * (1.0 + n) + + 795.0 * np.power(1.0 + n, 2) + + 504.0 * np.power(1.0 + n, 3) + + 183.0 * np.power(1.0 + n, 4) + + 36.0 * np.power(1.0 + n, 5) + + 3.0 * np.power(1.0 + n, 6) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + + S3 + ) + ) + ) + / np.power(5.0 + n, 2) + ) + ) + + 0.1530503487172192 + * ( + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 2.048824e6 + + 8.4339e6 * (1.0 + n) + + 1.595433e7 * np.power(1.0 + n, 2) + + 1.831824e7 * np.power(1.0 + n, 3) + + 1.419519e7 * np.power(1.0 + n, 4) + + 7.80975e6 * np.power(1.0 + n, 5) + + 3.124155e6 * np.power(1.0 + n, 6) + + 914760.0 * np.power(1.0 + n, 7) + + 194445.0 * np.power(1.0 + n, 8) + + 29250.0 * np.power(1.0 + n, 9) + + 2955.0 * np.power(1.0 + n, 10) + + 180.0 * np.power(1.0 + n, 11) + + 5.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + + S3 + ) + ) + / (6.0 + n) + + n + * ( + -1.0 / np.power(6.0 + n, 5) + + 1.0823232337111381 / (6.0 + n) + - ( + 1.0 + * ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + ) + / np.power(6.0 + n, 4) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(6.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 1628.0 + + 5050.0 * (1.0 + n) + + 6935.0 * np.power(1.0 + n, 2) + + 5495.0 * np.power(1.0 + n, 3) + + 2737.0 * np.power(1.0 + n, 4) + + 875.0 * np.power(1.0 + n, 5) + + 175.0 * np.power(1.0 + n, 6) + + 20.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + S3 + ) + ) + ) + / np.power(6.0 + n, 2) + ) + ) + - 0.10602798528818422 + * ( + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 6.3467712e7 + + 2.75413824e8 * (1.0 + n) + + 5.54256432e8 * np.power(1.0 + n, 2) + + 6.84826352e8 * np.power(1.0 + n, 3) + + 5.79544028e8 * np.power(1.0 + n, 4) + + 3.54873092e8 * np.power(1.0 + n, 5) + + 1.61970683e8 * np.power(1.0 + n, 6) + + 5.5932611e7 * np.power(1.0 + n, 7) + + 1.4676674e7 * np.power(1.0 + n, 8) + + 2.911041e6 * np.power(1.0 + n, 9) + + 429534.0 * np.power(1.0 + n, 10) + + 45717.0 * np.power(1.0 + n, 11) + + 3318.0 * np.power(1.0 + n, 12) + + 147.0 * np.power(1.0 + n, 13) + + 3.0 * np.power(1.0 + n, 14) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + S3 + ) + ) + / (7.0 + n) + + n + * ( + -1.0 / np.power(7.0 + n, 5) + + 1.0823232337111381 / (7.0 + n) + - ( + 1.0 + * ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 + ) + ) + / np.power(7.0 + n, 4) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(7.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + ) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + ) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 2.048824e6 + + 8.4339e6 * (1.0 + n) + + 1.595433e7 * np.power(1.0 + n, 2) + + 1.831824e7 * np.power(1.0 + n, 3) + + 1.419519e7 * np.power(1.0 + n, 4) + + 7.80975e6 * np.power(1.0 + n, 5) + + 3.124155e6 * np.power(1.0 + n, 6) + + 914760.0 * np.power(1.0 + n, 7) + + 194445.0 * np.power(1.0 + n, 8) + + 29250.0 * np.power(1.0 + n, 9) + + 2955.0 * np.power(1.0 + n, 10) + + 180.0 * np.power(1.0 + n, 11) + + 5.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + + S3 + ) + ) + ) + / np.power(7.0 + n, 2) + ) + ) + + 0.056951717764149916 + * ( + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 1.52759224512e11 + + 7.72859090304e11 * (1.0 + n) + + 1.840340570544e12 * np.power(1.0 + n, 2) + + 2.738393029568e12 * np.power(1.0 + n, 3) + + 2.850741832092e12 * np.power(1.0 + n, 4) + + 2.203027167432e12 * np.power(1.0 + n, 5) + + 1.308849323187e12 * np.power(1.0 + n, 6) + + 6.10929168192e11 * np.power(1.0 + n, 7) + + 2.2702816521e11 * np.power(1.0 + n, 8) + + 6.7650709672e10 * np.power(1.0 + n, 9) + + 1.6200316881e10 * np.power(1.0 + n, 10) + + 3.110018688e9 * np.power(1.0 + n, 11) + + 4.75055e8 * np.power(1.0 + n, 12) + + 5.6957208e7 * np.power(1.0 + n, 13) + + 5.242629e6 * np.power(1.0 + n, 14) + + 357504.0 * np.power(1.0 + n, 15) + + 17010.0 * np.power(1.0 + n, 16) + + 504.0 * np.power(1.0 + n, 17) + + 7.0 * np.power(1.0 + n, 18) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + S3 + ) + ) + / (8.0 + n) + + n + * ( + -1.0 / np.power(8.0 + n, 5) + + 1.0823232337111381 / (8.0 + n) + - ( + 1.0 + * ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + ) + / np.power(8.0 + n, 4) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(8.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 6.3467712e7 + + 2.75413824e8 * (1.0 + n) + + 5.54256432e8 * np.power(1.0 + n, 2) + + 6.84826352e8 * np.power(1.0 + n, 3) + + 5.79544028e8 * np.power(1.0 + n, 4) + + 3.54873092e8 * np.power(1.0 + n, 5) + + 1.61970683e8 * np.power(1.0 + n, 6) + + 5.5932611e7 * np.power(1.0 + n, 7) + + 1.4676674e7 * np.power(1.0 + n, 8) + + 2.911041e6 * np.power(1.0 + n, 9) + + 429534.0 * np.power(1.0 + n, 10) + + 45717.0 * np.power(1.0 + n, 11) + + 3318.0 * np.power(1.0 + n, 12) + + 147.0 * np.power(1.0 + n, 13) + + 3.0 * np.power(1.0 + n, 14) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + S3 + ) + ) + ) + / np.power(8.0 + n, 2) + ) + ) + - 0.019847559824380426 + * ( + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 2.176131861504e12 + + 1.135056707712e13 * (1.0 + n) + + 2.7974661270464e13 * np.power(1.0 + n, 2) + + 4.3284545841312e13 * np.power(1.0 + n, 3) + + 4.7115984701808e13 * np.power(1.0 + n, 4) + + 3.8323387681704e13 * np.power(1.0 + n, 5) + + 2.4153337475604e13 * np.power(1.0 + n, 6) + + 1.2072584201292e13 * np.power(1.0 + n, 7) + + 4.858675624797e12 * np.power(1.0 + n, 8) + + 1.589624084295e12 * np.power(1.0 + n, 9) + + 4.25052833112e11 * np.power(1.0 + n, 10) + + 9.304706925e10 * np.power(1.0 + n, 11) + + 1.6646348871e10 * np.power(1.0 + n, 12) + + 2.420753526e9 * np.power(1.0 + n, 13) + + 2.8338678e8 * np.power(1.0 + n, 14) + + 2.6298432e7 * np.power(1.0 + n, 15) + + 1.889595e6 * np.power(1.0 + n, 16) + + 101331.0 * np.power(1.0 + n, 17) + + 3816.0 * np.power(1.0 + n, 18) + + 90.0 * np.power(1.0 + n, 19) + + np.power(1.0 + n, 20) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + + S3 + ) + ) + / (9.0 + n) + + n + * ( + -1.0 / np.power(9.0 + n, 5) + + 1.0823232337111381 / (9.0 + n) + - ( + 1.0 + * ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + ) + / np.power(9.0 + n, 4) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(9.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 1.52759224512e11 + + 7.72859090304e11 * (1.0 + n) + + 1.840340570544e12 * np.power(1.0 + n, 2) + + 2.738393029568e12 * np.power(1.0 + n, 3) + + 2.850741832092e12 * np.power(1.0 + n, 4) + + 2.203027167432e12 * np.power(1.0 + n, 5) + + 1.308849323187e12 * np.power(1.0 + n, 6) + + 6.10929168192e11 * np.power(1.0 + n, 7) + + 2.2702816521e11 * np.power(1.0 + n, 8) + + 6.7650709672e10 * np.power(1.0 + n, 9) + + 1.6200316881e10 * np.power(1.0 + n, 10) + + 3.110018688e9 * np.power(1.0 + n, 11) + + 4.75055e8 * np.power(1.0 + n, 12) + + 5.6957208e7 * np.power(1.0 + n, 13) + + 5.242629e6 * np.power(1.0 + n, 14) + + 357504.0 * np.power(1.0 + n, 15) + + 17010.0 * np.power(1.0 + n, 16) + + 504.0 * np.power(1.0 + n, 17) + + 7.0 * np.power(1.0 + n, 18) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + S3 + ) + ) + ) + / np.power(9.0 + n, 2) + ) + ) + + 0.003243204652309423 + * ( + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 3.0 + * ( + 342192.0 + + 781800.0 * (1.0 + n) + + 723680.0 * np.power(1.0 + n, 2) + + 359100.0 * np.power(1.0 + n, 3) + + 105455.0 * np.power(1.0 + n, 4) + + 18900.0 * np.power(1.0 + n, 5) + + 2030.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + ) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 3.0 + * ( + 342192.0 + + 781800.0 * (1.0 + n) + + 723680.0 * np.power(1.0 + n, 2) + + 359100.0 * np.power(1.0 + n, 3) + + 105455.0 * np.power(1.0 + n, 4) + + 18900.0 * np.power(1.0 + n, 5) + + 2030.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + ) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 3.0 + * ( + 6.7586510592e10 + + 2.7735912e11 * (1.0 + n) + + 5.25886236e11 * np.power(1.0 + n, 2) + + 6.098325648e11 * np.power(1.0 + n, 3) + + 4.8346372324e11 * np.power(1.0 + n, 4) + + 2.77716663e11 * np.power(1.0 + n, 5) + + 1.195744907e11 * np.power(1.0 + n, 6) + + 3.937668588e10 * np.power(1.0 + n, 7) + + 1.0027662147e10 * np.power(1.0 + n, 8) + + 1.982481e9 * np.power(1.0 + n, 9) + + 3.0344942e8 * np.power(1.0 + n, 10) + + 3.560508e7 * np.power(1.0 + n, 11) + + 3.141418e6 * np.power(1.0 + n, 12) + + 201600.0 * np.power(1.0 + n, 13) + + 8880.0 * np.power(1.0 + n, 14) + + 240.0 * np.power(1.0 + n, 15) + + 3.0 * np.power(1.0 + n, 16) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 3.0 + * ( + 1.905865096469299e16 + + 1.100489126093568e17 * (1.0 + n) + + 3.026775163197197e17 * np.power(1.0 + n, 2) + + 5.274174874222368e17 * np.power(1.0 + n, 3) + + 6.532963289874519e17 * np.power(1.0 + n, 4) + + 6.118731135138024e17 * np.power(1.0 + n, 5) + + 4.5005054609223366e17 * np.power(1.0 + n, 6) + + 2.6656016992225488e17 * np.power(1.0 + n, 7) + + 1.2935179046741138e17 * np.power(1.0 + n, 8) + + 5.2054701631938e16 * np.power(1.0 + n, 9) + + 1.751929057804686e16 * np.power(1.0 + n, 10) + + 4.95861919609626e15 * np.power(1.0 + n, 11) + + 1.184087108357771e15 * np.power(1.0 + n, 12) + + 2.388131885349e14 * np.power(1.0 + n, 13) + + 4.064171822907e13 * np.power(1.0 + n, 14) + + 5.818192578e12 * np.power(1.0 + n, 15) + + 6.96833685225e11 * np.power(1.0 + n, 16) + + 6.92402094e10 * np.power(1.0 + n, 17) + + 5.63902616e9 * np.power(1.0 + n, 18) + + 3.699297e8 * np.power(1.0 + n, 19) + + 1.9060797e7 * np.power(1.0 + n, 20) + + 742500.0 * np.power(1.0 + n, 21) + + 20550.0 * np.power(1.0 + n, 22) + + 360.0 * np.power(1.0 + n, 23) + + 3.0 * np.power(1.0 + n, 24) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + * np.power(10.0 + n, 3) + ) + + S3 + ) + ) + / (10.0 + n) + + n + * ( + -1.0 / np.power(10.0 + n, 5) + + 1.0823232337111381 / (10.0 + n) + - ( + 1.0 + * ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + ) + / np.power(10.0 + n, 4) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(10.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 2.176131861504e12 + + 1.135056707712e13 * (1.0 + n) + + 2.7974661270464e13 * np.power(1.0 + n, 2) + + 4.3284545841312e13 * np.power(1.0 + n, 3) + + 4.7115984701808e13 * np.power(1.0 + n, 4) + + 3.8323387681704e13 * np.power(1.0 + n, 5) + + 2.4153337475604e13 * np.power(1.0 + n, 6) + + 1.2072584201292e13 * np.power(1.0 + n, 7) + + 4.858675624797e12 * np.power(1.0 + n, 8) + + 1.589624084295e12 * np.power(1.0 + n, 9) + + 4.25052833112e11 * np.power(1.0 + n, 10) + + 9.304706925e10 * np.power(1.0 + n, 11) + + 1.6646348871e10 * np.power(1.0 + n, 12) + + 2.420753526e9 * np.power(1.0 + n, 13) + + 2.8338678e8 * np.power(1.0 + n, 14) + + 2.6298432e7 * np.power(1.0 + n, 15) + + 1.889595e6 * np.power(1.0 + n, 16) + + 101331.0 * np.power(1.0 + n, 17) + + 3816.0 * np.power(1.0 + n, 18) + + 90.0 * np.power(1.0 + n, 19) + + np.power(1.0 + n, 20) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + + S3 + ) + ) + ) + / np.power(10.0 + n, 2) + ) + ) + ) + + +@nb.njit("c16(c16,c16,c16)", cache=True) +def F12(n, S1, S2): + return ( + 0.18755232447534953 + - 0.9999999952263307 + * ( + 1.2020569031595942 / (1.0 + n) + + n + * ( + np.power(1.0 + n, -5) + - 1.2020569031595942 / np.power(1.0 + n, 2) + + 0.27058080842778454 / (1.0 + n) + + S1 / np.power(1.0 + n, 4) + + (0.5 * np.power(S1, 2) + 0.5 * S2) / np.power(1.0 + n, 3) + ) + - ( + 1.0 + * ( + 0.5 * np.power(1 / (1.0 + n) + S1, 2) + + 0.5 * (np.power(1.0 + n, -2) + S2) + ) + ) + / np.power(1.0 + n, 2) + ) + + 0.49999902059348167 + * ( + 1.2020569031595942 / (2.0 + n) + - ( + 1.0 + * ( + 0.5 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 2) + + 0.5 * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) + ) + ) + / np.power(2.0 + n, 2) + + n + * ( + np.power(2.0 + n, -5) + - 1.2020569031595942 / np.power(2.0 + n, 2) + + 0.27058080842778454 / (2.0 + n) + + (1 / (1.0 + n) + S1) / np.power(2.0 + n, 4) + + ( + 0.5 * np.power(1 / (1.0 + n) + S1, 2) + + 0.5 * (np.power(1.0 + n, -2) + S2) + ) + / np.power(2.0 + n, 3) + ) + ) + - 0.3332995604546604 + * ( + 1.2020569031595942 / (3.0 + n) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S2 + ) + ) + ) + / np.power(3.0 + n, 2) + + n + * ( + np.power(3.0 + n, -5) + - 1.2020569031595942 / np.power(3.0 + n, 2) + + 0.27058080842778454 / (3.0 + n) + + (1 / (1.0 + n) + 1 / (2.0 + n) + S1) / np.power(3.0 + n, 4) + + ( + 0.5 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 2) + + 0.5 * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) + ) + / np.power(3.0 + n, 3) + ) + ) + + 0.24954082848379078 + * ( + 1.2020569031595942 / (4.0 + n) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(4.0 + n, 2) + + n + * ( + np.power(4.0 + n, -5) + - 1.2020569031595942 / np.power(4.0 + n, 2) + + 0.27058080842778454 / (4.0 + n) + + ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + / np.power(4.0 + n, 4) + + ( + 0.5 + * np.power( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S2 + ) + ) + / np.power(4.0 + n, 3) + ) + ) + - 0.1967571967137462 + * ( + 1.2020569031595942 / (5.0 + n) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(5.0 + n, 2) + + n + * ( + np.power(5.0 + n, -5) + - 1.2020569031595942 / np.power(5.0 + n, 2) + + 0.27058080842778454 / (5.0 + n) + + ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + / np.power(5.0 + n, 4) + + ( + 0.5 + * np.power( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + S2 + ) + ) + / np.power(5.0 + n, 3) + ) + ) + + 0.1530503487172192 + * ( + 1.2020569031595942 / (6.0 + n) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(6.0 + n, 2) + + n + * ( + np.power(6.0 + n, -5) + - 1.2020569031595942 / np.power(6.0 + n, 2) + + 0.27058080842778454 / (6.0 + n) + + ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + / np.power(6.0 + n, 4) + + ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + S2 + ) + ) + / np.power(6.0 + n, 3) + ) + ) + - 0.10602798528818422 + * ( + 1.2020569031595942 / (7.0 + n) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(7.0 + n, 2) + + n + * ( + np.power(7.0 + n, -5) + - 1.2020569031595942 / np.power(7.0 + n, 2) + + 0.27058080842778454 / (7.0 + n) + + ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 + ) + / np.power(7.0 + n, 4) + + ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + S2 + ) + ) + / np.power(7.0 + n, 3) + ) + ) + + 0.056951717764149916 + * ( + 1.2020569031595942 / (8.0 + n) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(8.0 + n, 2) + + n + * ( + np.power(8.0 + n, -5) + - 1.2020569031595942 / np.power(8.0 + n, 2) + + 0.27058080842778454 / (8.0 + n) + + ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + / np.power(8.0 + n, 4) + + ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S2 + ) + ) + / np.power(8.0 + n, 3) + ) + ) + - 0.019847559824380426 + * ( + 1.2020569031595942 / (9.0 + n) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(9.0 + n, 2) + + n + * ( + np.power(9.0 + n, -5) + - 1.2020569031595942 / np.power(9.0 + n, 2) + + 0.27058080842778454 / (9.0 + n) + + ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + / np.power(9.0 + n, 4) + + ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S2 + ) + ) + / np.power(9.0 + n, 3) + ) + ) + + 0.003243204652309423 + * ( + 1.2020569031595942 / (10.0 + n) + - ( + 1.0 + * ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 3.0 + * ( + 342192.0 + + 781800.0 * (1.0 + n) + + 723680.0 * np.power(1.0 + n, 2) + + 359100.0 * np.power(1.0 + n, 3) + + 105455.0 * np.power(1.0 + n, 4) + + 18900.0 * np.power(1.0 + n, 5) + + 2030.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 3.0 + * ( + 6.7586510592e10 + + 2.7735912e11 * (1.0 + n) + + 5.25886236e11 * np.power(1.0 + n, 2) + + 6.098325648e11 * np.power(1.0 + n, 3) + + 4.8346372324e11 * np.power(1.0 + n, 4) + + 2.77716663e11 * np.power(1.0 + n, 5) + + 1.195744907e11 * np.power(1.0 + n, 6) + + 3.937668588e10 * np.power(1.0 + n, 7) + + 1.0027662147e10 * np.power(1.0 + n, 8) + + 1.982481e9 * np.power(1.0 + n, 9) + + 3.0344942e8 * np.power(1.0 + n, 10) + + 3.560508e7 * np.power(1.0 + n, 11) + + 3.141418e6 * np.power(1.0 + n, 12) + + 201600.0 * np.power(1.0 + n, 13) + + 8880.0 * np.power(1.0 + n, 14) + + 240.0 * np.power(1.0 + n, 15) + + 3.0 * np.power(1.0 + n, 16) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + ) + + S2 + ) + ) + ) + / np.power(10.0 + n, 2) + + n + * ( + np.power(10.0 + n, -5) + - 1.2020569031595942 / np.power(10.0 + n, 2) + + 0.27058080842778454 / (10.0 + n) + + ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + / np.power(10.0 + n, 4) + + ( + 0.5 + * np.power( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1, + 2, + ) + + 0.5 + * ( + np.power(1.0 + n, -2) + + ( + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) + ) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + S2 + ) + ) + / np.power(10.0 + n, 3) + ) + ) + ) + + +@nb.njit("c16(c16,c16)", cache=True) +def F9(n, S1): + return ( + 0.06236473052300693 * n + + (0.2690947900632558 * n) / (2.0 + n) + - (0.12825410062391376 * n) / (3.0 + n) + + (0.007553694508943639 * n) / (4.0 + n) + + (0.030446610389993342 * n) / (5.0 + n) + - (0.11774020607944516 * n) / (6.0 + n) + + (0.33716180147388786 * n) / (7.0 + n) + - (0.6676623948212598 * n) / (8.0 + n) + + (0.9225597682535133 * n) / (9.0 + n) + - (0.8726283036193748 * n) / (10.0 + n) + + (0.5398117849858193 * n) / (11.0 + n) + - (0.1970839223372511 * n) / (12.0 + n) + + (0.03230590731253853 * n) / (13.0 + n) + + 0.21793029342350395 * (-1.0 + 1 / (1.0 + n)) + - 0.000925925925925926 + * n + * ( + 67.35391078053772 + + 993.5438760599122 / (1.0 + n) + + 185.10074515651877 / (2.0 + n) + - 21.841303653529422 / (3.0 + n) + + (180.0 * (1.0 + (1.0 + n) * S1)) / np.power(1.0 + n, 2) + - (180.0 * (1.0 + (2.0 + n) * (1 / (1.0 + n) + S1))) / np.power(2.0 + n, 2) + + (60.0 * (1.0 + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1))) + / np.power(3.0 + n, 2) + - ( + 1228.9090924080292 + * ( + 1.0 + + n + * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) + ) + ) + / np.power(n, 2) + ) + ) + + +@nb.njit("c16(c16,c16,c16,c16,c16,c16)", cache=True) +def F16(n, S1, Sm1, Sm2, Sm3, Sm21): + return ( + -0.23444040559418688 + - 0.9999999952263307 + * ( + -0.419833592426477 / (1.0 + n) + - (0.18119485915332012 * np.power(-1.0, 1.0 + n)) / (1.0 + n) + - (0.6010284515797971 * np.power(-1.0, 2.0 + n)) / (1.0 + n) + - (0.8224670334241131 * np.power(-1.0, 1.0 + n) * (1 / (1.0 + n) + S1)) + / (1.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 2.0 + n) + * (Sm1 - (1.0 * np.power(-1.0, n)) / (1.0 + n)) + ) + / (1.0 + n) + + ( + np.power(-1.0, 2.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + (1 / (1.0 + n) + S1) + * (Sm2 - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2)) + ) + ) + / (1.0 + n) + + n + * ( + np.power(1.0 + n, -5) + - 0.8224670334241131 / np.power(1.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, n)) / np.power(1.0 + n, 3) + + 0.419833592426477 / np.power(1.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 1.0 + n)) / np.power(1.0 + n, 2) + - 0.3382260105347306 / (1.0 + n) + - (0.8224670334241131 * np.power(-1.0, n) * S1) / np.power(1.0 + n, 2) + - (0.8224670334241131 * np.power(-1.0, 1.0 + n) * Sm1) + / np.power(1.0 + n, 2) + + (np.power(-1.0, 1.0 + n) * Sm2) / np.power(1.0 + n, 3) + + ( + np.power(-1.0, 1.0 + n) + * ( + S1 * Sm2 + - 1.0 * Sm21 + + Sm3 + + np.power(-1.0, n) / np.power(1.0 + n, 3) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (1 / (1.0 + n) + S1) * np.power(-1.0, n)) + / np.power(1.0 + n, 2) + ) + ) + / np.power(1.0 + n, 2) + ) + ) + + 0.49999902059348167 + * ( + -0.419833592426477 / (2.0 + n) + - (0.18119485915332012 * np.power(-1.0, 2.0 + n)) / (2.0 + n) + - (0.6010284515797971 * np.power(-1.0, 3.0 + n)) / (2.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 2.0 + n) + * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + ) + / (2.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 3.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + np.power(-1.0, n) / (2.0 + n) + ) + ) + / (2.0 + n) + + ( + np.power(-1.0, 3.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (1 / (1.0 + n) + S1) * np.power(-1.0, n)) + / np.power(2.0 + n, 2) + + (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + np.power(-1.0, n) / np.power(2.0 + n, 2) + ) + ) + ) + / (2.0 + n) + + n + * ( + np.power(2.0 + n, -5) + - 0.8224670334241131 / np.power(2.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 1.0 + n)) / np.power(2.0 + n, 3) + + 0.419833592426477 / np.power(2.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 1.0 + n)) / np.power(2.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 2.0 + n)) / np.power(2.0 + n, 2) + - 0.3382260105347306 / (2.0 + n) + - (0.8224670334241131 * np.power(-1.0, 1.0 + n) * (1 / (1.0 + n) + S1)) + / np.power(2.0 + n, 2) + + ( + np.power(-1.0, 2.0 + n) + * (Sm2 - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2)) + ) + / np.power(2.0 + n, 3) + - ( + 0.8224670334241131 + * np.power(-1.0, 2.0 + n) + * (Sm1 - (1.0 * np.power(-1.0, n)) / (1.0 + n)) + ) + / np.power(2.0 + n, 2) + + ( + np.power(-1.0, 2.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + (1 / (1.0 + n) + S1) + * (Sm2 - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2)) + ) + ) + / np.power(2.0 + n, 2) + ) + ) + - 0.3332995604546604 + * ( + -0.419833592426477 / (3.0 + n) + - (0.18119485915332012 * np.power(-1.0, 3.0 + n)) / (3.0 + n) + - (0.6010284515797971 * np.power(-1.0, 4.0 + n)) / (3.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 3.0 + n) + * ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + ) + / (3.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 4.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + np.power(-1.0, n) / ((2.0 + n) * (3.0 + n)) + ) + ) + / (3.0 + n) + + ( + np.power(-1.0, 4.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + - ( + 1.0 + * (-7.0 - 9.0 * (1.0 + n) - 3.0 * np.power(1.0 + n, 2)) + * np.power(-1.0, n) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + ( + ( + -5.0 + - 4.0 * (1.0 + n) + + np.power(1.0 + n, 2) + + np.power(1.0 + n, 3) + ) + * np.power(-1.0, n) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + (-3.0 - 2.0 * (1.0 + n)) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (-3.0 - 2.0 * (1.0 + n)) * np.power(-1.0, n)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + ) + ) + ) + / (3.0 + n) + + n + * ( + np.power(3.0 + n, -5) + - 0.8224670334241131 / np.power(3.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 2.0 + n)) / np.power(3.0 + n, 3) + + 0.419833592426477 / np.power(3.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 2.0 + n)) / np.power(3.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 3.0 + n)) / np.power(3.0 + n, 2) + - 0.3382260105347306 / (3.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 2.0 + n) + * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + ) + / np.power(3.0 + n, 2) + + ( + np.power(-1.0, 3.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + np.power(-1.0, n) / np.power(2.0 + n, 2) + ) + ) + / np.power(3.0 + n, 3) + - ( + 0.8224670334241131 + * np.power(-1.0, 3.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + np.power(-1.0, n) / (2.0 + n) + ) + ) + / np.power(3.0 + n, 2) + + ( + np.power(-1.0, 3.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (1 / (1.0 + n) + S1) * np.power(-1.0, n)) + / np.power(2.0 + n, 2) + + (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + np.power(-1.0, n) / np.power(2.0 + n, 2) + ) + ) + ) + / np.power(3.0 + n, 2) + ) + ) + + 0.24954082848379078 + * ( + -0.419833592426477 / (4.0 + n) + - (0.18119485915332012 * np.power(-1.0, 4.0 + n)) / (4.0 + n) + - (0.6010284515797971 * np.power(-1.0, 5.0 + n)) / (4.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 4.0 + n) + * ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + ) + / (4.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 5.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * (-5.0 - 4.0 * (1.0 + n) - 1.0 * np.power(1.0 + n, 2)) + * np.power(-1.0, n) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + ) + ) + / (4.0 + n) + + ( + np.power(-1.0, 5.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + ( + -179.0 + - 423.0 * (1.0 + n) + - 425.0 * np.power(1.0 + n, 2) + - 245.0 * np.power(1.0 + n, 3) + - 90.0 * np.power(1.0 + n, 4) + - 20.0 * np.power(1.0 + n, 5) + - 2.0 * np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + - ( + 1.0 + * ( + -197.0 + - 468.0 * (1.0 + n) + - 453.0 * np.power(1.0 + n, 2) + - 232.0 * np.power(1.0 + n, 3) + - 69.0 * np.power(1.0 + n, 4) + - 12.0 * np.power(1.0 + n, 5) + - 1.0 * np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -31.0 + - 48.0 * (1.0 + n) + - 28.0 * np.power(1.0 + n, 2) + - 8.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -31.0 + - 48.0 * (1.0 + n) + - 28.0 * np.power(1.0 + n, 2) + - 8.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + ) + ) + ) + / (4.0 + n) + + n + * ( + np.power(4.0 + n, -5) + - 0.8224670334241131 / np.power(4.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 3.0 + n)) / np.power(4.0 + n, 3) + + 0.419833592426477 / np.power(4.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 3.0 + n)) / np.power(4.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 4.0 + n)) / np.power(4.0 + n, 2) + - 0.3382260105347306 / (4.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 3.0 + n) + * ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + ) + / np.power(4.0 + n, 2) + - ( + 0.8224670334241131 + * np.power(-1.0, 4.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + np.power(-1.0, n) / ((2.0 + n) * (3.0 + n)) + ) + ) + / np.power(4.0 + n, 2) + + ( + np.power(-1.0, 4.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (-3.0 - 2.0 * (1.0 + n)) * np.power(-1.0, n)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + ) + ) + / np.power(4.0 + n, 3) + + ( + np.power(-1.0, 4.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + - ( + 1.0 + * (-7.0 - 9.0 * (1.0 + n) - 3.0 * np.power(1.0 + n, 2)) + * np.power(-1.0, n) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + ( + ( + -5.0 + - 4.0 * (1.0 + n) + + np.power(1.0 + n, 2) + + np.power(1.0 + n, 3) + ) + * np.power(-1.0, n) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + (-3.0 - 2.0 * (1.0 + n)) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (-3.0 - 2.0 * (1.0 + n)) * np.power(-1.0, n)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + ) + ) + ) + / np.power(4.0 + n, 2) + ) + ) + - 0.1967571967137462 + * ( + -0.419833592426477 / (5.0 + n) + - (0.18119485915332012 * np.power(-1.0, 5.0 + n)) / (5.0 + n) + - (0.6010284515797971 * np.power(-1.0, 6.0 + n)) / (5.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 5.0 + n) + * ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + ) + / (5.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 6.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + ( + 2.0 + * (7.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + * np.power(-1.0, n) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + ) + ) + / (5.0 + n) + + ( + np.power(-1.0, 6.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + 2.0 + * ( + 6196.0 + + 19110.0 * (1.0 + n) + + 25497.0 * np.power(1.0 + n, 2) + + 19295.0 * np.power(1.0 + n, 3) + + 9117.0 * np.power(1.0 + n, 4) + + 2775.0 * np.power(1.0 + n, 5) + + 535.0 * np.power(1.0 + n, 6) + + 60.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + ( + ( + -9656.0 + - 26544.0 * (1.0 + n) + - 29682.0 * np.power(1.0 + n, 2) + - 16521.0 * np.power(1.0 + n, 3) + - 3745.0 * np.power(1.0 + n, 4) + + 787.0 * np.power(1.0 + n, 5) + + 793.0 * np.power(1.0 + n, 6) + + 236.0 * np.power(1.0 + n, 7) + + 34.0 * np.power(1.0 + n, 8) + + 2.0 * np.power(1.0 + n, 9) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 46.0 + + 70.0 * (1.0 + n) + + 39.0 * np.power(1.0 + n, 2) + + 10.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 46.0 + + 70.0 * (1.0 + n) + + 39.0 * np.power(1.0 + n, 2) + + 10.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + ) + ) + ) + / (5.0 + n) + + n + * ( + np.power(5.0 + n, -5) + - 0.8224670334241131 / np.power(5.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 4.0 + n)) / np.power(5.0 + n, 3) + + 0.419833592426477 / np.power(5.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 4.0 + n)) / np.power(5.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 5.0 + n)) / np.power(5.0 + n, 2) + - 0.3382260105347306 / (5.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 4.0 + n) + * ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + ) + / np.power(5.0 + n, 2) + - ( + 0.8224670334241131 + * np.power(-1.0, 5.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * (-5.0 - 4.0 * (1.0 + n) - 1.0 * np.power(1.0 + n, 2)) + * np.power(-1.0, n) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + ) + ) + / np.power(5.0 + n, 2) + + ( + np.power(-1.0, 5.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -31.0 + - 48.0 * (1.0 + n) + - 28.0 * np.power(1.0 + n, 2) + - 8.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + ) + ) + / np.power(5.0 + n, 3) + + ( + np.power(-1.0, 5.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + ( + -179.0 + - 423.0 * (1.0 + n) + - 425.0 * np.power(1.0 + n, 2) + - 245.0 * np.power(1.0 + n, 3) + - 90.0 * np.power(1.0 + n, 4) + - 20.0 * np.power(1.0 + n, 5) + - 2.0 * np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + - ( + 1.0 + * ( + -197.0 + - 468.0 * (1.0 + n) + - 453.0 * np.power(1.0 + n, 2) + - 232.0 * np.power(1.0 + n, 3) + - 69.0 * np.power(1.0 + n, 4) + - 12.0 * np.power(1.0 + n, 5) + - 1.0 * np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -31.0 + - 48.0 * (1.0 + n) + - 28.0 * np.power(1.0 + n, 2) + - 8.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -31.0 + - 48.0 * (1.0 + n) + - 28.0 * np.power(1.0 + n, 2) + - 8.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + ) + ) + ) + / np.power(5.0 + n, 2) + ) + ) + + 0.1530503487172192 + * ( + -0.419833592426477 / (6.0 + n) + - (0.18119485915332012 * np.power(-1.0, 6.0 + n)) / (6.0 + n) + - (0.6010284515797971 * np.power(-1.0, 7.0 + n)) / (6.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 6.0 + n) + * ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 + ) + ) + / (6.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 7.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * ( + -94.0 + - 114.0 * (1.0 + n) + - 55.0 * np.power(1.0 + n, 2) + - 12.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + ) + ) + / (6.0 + n) + + ( + np.power(-1.0, 7.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + ( + -1.364824e6 + - 4.959e6 * (1.0 + n) + - 8.21809e6 * np.power(1.0 + n, 2) + - 8.317171e6 * np.power(1.0 + n, 3) + - 5.805556e6 * np.power(1.0 + n, 4) + - 2.979747e6 * np.power(1.0 + n, 5) + - 1.160441e6 * np.power(1.0 + n, 6) + - 345225.0 * np.power(1.0 + n, 7) + - 77357.0 * np.power(1.0 + n, 8) + - 12617.0 * np.power(1.0 + n, 9) + - 1409.0 * np.power(1.0 + n, 10) + - 96.0 * np.power(1.0 + n, 11) + - 3.0 * np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + - ( + 1.0 + * ( + -1.562824e6 + - 5.7933e6 * (1.0 + n) + - 9.66711e6 * np.power(1.0 + n, 2) + - 9.628272e6 * np.power(1.0 + n, 3) + - 6.401058e6 * np.power(1.0 + n, 4) + - 3.007494e6 * np.power(1.0 + n, 5) + - 1.029715e6 * np.power(1.0 + n, 6) + - 260424.0 * np.power(1.0 + n, 7) + - 48597.0 * np.power(1.0 + n, 8) + - 6570.0 * np.power(1.0 + n, 9) + - 615.0 * np.power(1.0 + n, 10) + - 36.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -12076.0 + - 29100.0 * (1.0 + n) + - 30230.0 * np.power(1.0 + n, 2) + - 17964.0 * np.power(1.0 + n, 3) + - 6753.0 * np.power(1.0 + n, 4) + - 1656.0 * np.power(1.0 + n, 5) + - 260.0 * np.power(1.0 + n, 6) + - 24.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -12076.0 + - 29100.0 * (1.0 + n) + - 30230.0 * np.power(1.0 + n, 2) + - 17964.0 * np.power(1.0 + n, 3) + - 6753.0 * np.power(1.0 + n, 4) + - 1656.0 * np.power(1.0 + n, 5) + - 260.0 * np.power(1.0 + n, 6) + - 24.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + ) + ) + ) + / (6.0 + n) + + n + * ( + np.power(6.0 + n, -5) + - 0.8224670334241131 / np.power(6.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 5.0 + n)) / np.power(6.0 + n, 3) + + 0.419833592426477 / np.power(6.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 5.0 + n)) / np.power(6.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 6.0 + n)) / np.power(6.0 + n, 2) + - 0.3382260105347306 / (6.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 5.0 + n) + * ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + ) + / np.power(6.0 + n, 2) + - ( + 0.8224670334241131 + * np.power(-1.0, 6.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + ( + 2.0 + * (7.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + * np.power(-1.0, n) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + ) + ) + / np.power(6.0 + n, 2) + + ( + np.power(-1.0, 6.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 46.0 + + 70.0 * (1.0 + n) + + 39.0 * np.power(1.0 + n, 2) + + 10.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + ) + ) + / np.power(6.0 + n, 3) + + ( + np.power(-1.0, 6.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + 2.0 + * ( + 6196.0 + + 19110.0 * (1.0 + n) + + 25497.0 * np.power(1.0 + n, 2) + + 19295.0 * np.power(1.0 + n, 3) + + 9117.0 * np.power(1.0 + n, 4) + + 2775.0 * np.power(1.0 + n, 5) + + 535.0 * np.power(1.0 + n, 6) + + 60.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + ( + ( + -9656.0 + - 26544.0 * (1.0 + n) + - 29682.0 * np.power(1.0 + n, 2) + - 16521.0 * np.power(1.0 + n, 3) + - 3745.0 * np.power(1.0 + n, 4) + + 787.0 * np.power(1.0 + n, 5) + + 793.0 * np.power(1.0 + n, 6) + + 236.0 * np.power(1.0 + n, 7) + + 34.0 * np.power(1.0 + n, 8) + + 2.0 * np.power(1.0 + n, 9) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 46.0 + + 70.0 * (1.0 + n) + + 39.0 * np.power(1.0 + n, 2) + + 10.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 46.0 + + 70.0 * (1.0 + n) + + 39.0 * np.power(1.0 + n, 2) + + 10.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + ) + ) + ) + / np.power(6.0 + n, 2) + ) + ) + - 0.10602798528818422 + * ( + -0.419833592426477 / (7.0 + n) + - (0.18119485915332012 * np.power(-1.0, 7.0 + n)) / (7.0 + n) + - (0.6010284515797971 * np.power(-1.0, 8.0 + n)) / (7.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 7.0 + n) + * ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + ) + / (7.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 8.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + ( + 3.0 + * ( + 148.0 + + 168.0 * (1.0 + n) + + 73.0 * np.power(1.0 + n, 2) + + 14.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + ) + ) + / (7.0 + n) + + ( + np.power(-1.0, 8.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + 9.0 + * ( + 3.7315776e7 + + 1.56477888e8 * (1.0 + n) + + 3.00572848e8 * np.power(1.0 + n, 2) + + 3.51218448e8 * np.power(1.0 + n, 3) + + 2.79551676e8 * np.power(1.0 + n, 4) + + 1.60708716e8 * np.power(1.0 + n, 5) + + 6.8959587e7 * np.power(1.0 + n, 6) + + 2.2477189e7 * np.power(1.0 + n, 7) + + 5.600212e6 * np.power(1.0 + n, 8) + + 1.062467e6 * np.power(1.0 + n, 9) + + 151200.0 * np.power(1.0 + n, 10) + + 15659.0 * np.power(1.0 + n, 11) + + 1116.0 * np.power(1.0 + n, 12) + + 49.0 * np.power(1.0 + n, 13) + + np.power(1.0 + n, 14) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + ( + ( + -2.69400384e8 + - 1.055773152e9 * (1.0 + n) + - 1.862215728e9 * np.power(1.0 + n, 2) + - 1.946883032e9 * np.power(1.0 + n, 3) + - 1.328424984e9 * np.power(1.0 + n, 4) + - 6.04538588e8 * np.power(1.0 + n, 5) + - 1.71139894e8 * np.power(1.0 + n, 6) + - 1.745252e7 * np.power(1.0 + n, 7) + + 8.746623e6 * np.power(1.0 + n, 8) + + 5.172041e6 * np.power(1.0 + n, 9) + + 1.470723e6 * np.power(1.0 + n, 10) + + 270665.0 * np.power(1.0 + n, 11) + + 33685.0 * np.power(1.0 + n, 12) + + 2759.0 * np.power(1.0 + n, 13) + + 135.0 * np.power(1.0 + n, 14) + + 3.0 * np.power(1.0 + n, 15) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 3.0 + * (7.0 + 2.0 * (1.0 + n)) + * ( + 20016.0 + + 47936.0 * (1.0 + n) + + 49184.0 * np.power(1.0 + n, 2) + + 28560.0 * np.power(1.0 + n, 3) + + 10321.0 * np.power(1.0 + n, 4) + + 2380.0 * np.power(1.0 + n, 5) + + 342.0 * np.power(1.0 + n, 6) + + 28.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 3.0 + * (7.0 + 2.0 * (1.0 + n)) + * ( + 20016.0 + + 47936.0 * (1.0 + n) + + 49184.0 * np.power(1.0 + n, 2) + + 28560.0 * np.power(1.0 + n, 3) + + 10321.0 * np.power(1.0 + n, 4) + + 2380.0 * np.power(1.0 + n, 5) + + 342.0 * np.power(1.0 + n, 6) + + 28.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + ) + ) + ) + / (7.0 + n) + + n + * ( + np.power(7.0 + n, -5) + - 0.8224670334241131 / np.power(7.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 6.0 + n)) / np.power(7.0 + n, 3) + + 0.419833592426477 / np.power(7.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 6.0 + n)) / np.power(7.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 7.0 + n)) / np.power(7.0 + n, 2) + - 0.3382260105347306 / (7.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 6.0 + n) + * ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 + ) + ) + / np.power(7.0 + n, 2) + - ( + 0.8224670334241131 + * np.power(-1.0, 7.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * ( + -94.0 + - 114.0 * (1.0 + n) + - 55.0 * np.power(1.0 + n, 2) + - 12.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + ) + ) + / np.power(7.0 + n, 2) + + ( + np.power(-1.0, 7.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -12076.0 + - 29100.0 * (1.0 + n) + - 30230.0 * np.power(1.0 + n, 2) + - 17964.0 * np.power(1.0 + n, 3) + - 6753.0 * np.power(1.0 + n, 4) + - 1656.0 * np.power(1.0 + n, 5) + - 260.0 * np.power(1.0 + n, 6) + - 24.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + ) + ) + / np.power(7.0 + n, 3) + + ( + np.power(-1.0, 7.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + ( + -1.364824e6 + - 4.959e6 * (1.0 + n) + - 8.21809e6 * np.power(1.0 + n, 2) + - 8.317171e6 * np.power(1.0 + n, 3) + - 5.805556e6 * np.power(1.0 + n, 4) + - 2.979747e6 * np.power(1.0 + n, 5) + - 1.160441e6 * np.power(1.0 + n, 6) + - 345225.0 * np.power(1.0 + n, 7) + - 77357.0 * np.power(1.0 + n, 8) + - 12617.0 * np.power(1.0 + n, 9) + - 1409.0 * np.power(1.0 + n, 10) + - 96.0 * np.power(1.0 + n, 11) + - 3.0 * np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + - ( + 1.0 + * ( + -1.562824e6 + - 5.7933e6 * (1.0 + n) + - 9.66711e6 * np.power(1.0 + n, 2) + - 9.628272e6 * np.power(1.0 + n, 3) + - 6.401058e6 * np.power(1.0 + n, 4) + - 3.007494e6 * np.power(1.0 + n, 5) + - 1.029715e6 * np.power(1.0 + n, 6) + - 260424.0 * np.power(1.0 + n, 7) + - 48597.0 * np.power(1.0 + n, 8) + - 6570.0 * np.power(1.0 + n, 9) + - 615.0 * np.power(1.0 + n, 10) + - 36.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -12076.0 + - 29100.0 * (1.0 + n) + - 30230.0 * np.power(1.0 + n, 2) + - 17964.0 * np.power(1.0 + n, 3) + - 6753.0 * np.power(1.0 + n, 4) + - 1656.0 * np.power(1.0 + n, 5) + - 260.0 * np.power(1.0 + n, 6) + - 24.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -12076.0 + - 29100.0 * (1.0 + n) + - 30230.0 * np.power(1.0 + n, 2) + - 17964.0 * np.power(1.0 + n, 3) + - 6753.0 * np.power(1.0 + n, 4) + - 1656.0 * np.power(1.0 + n, 5) + - 260.0 * np.power(1.0 + n, 6) + - 24.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + ) + ) + ) + / np.power(7.0 + n, 2) + ) + ) + + 0.056951717764149916 + * ( + -0.419833592426477 / (8.0 + n) + - (0.18119485915332012 * np.power(-1.0, 8.0 + n)) / (8.0 + n) + - (0.6010284515797971 * np.power(-1.0, 9.0 + n)) / (8.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 8.0 + n) + * ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + ) + / (8.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 9.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * ( + -3828.0 + - 5736.0 * (1.0 + n) + - 3661.0 * np.power(1.0 + n, 2) + - 1248.0 * np.power(1.0 + n, 3) + - 238.0 * np.power(1.0 + n, 4) + - 24.0 * np.power(1.0 + n, 5) + - 1.0 * np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + ) + ) + / (8.0 + n) + + ( + np.power(-1.0, 9.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + - ( + 1.0 + * ( + -1.15567048512e11 + - 5.35159384704e11 * (1.0 + n) + - 1.151188217424e12 * np.power(1.0 + n, 2) + - 1.53078715296e12 * np.power(1.0 + n, 3) + - 1.412584727652e12 * np.power(1.0 + n, 4) + - 9.62381167416e11 * np.power(1.0 + n, 5) + - 5.02598549197e11 * np.power(1.0 + n, 6) + - 2.0609943264e11 * np.power(1.0 + n, 7) + - 6.7393018182e10 * np.power(1.0 + n, 8) + - 1.7735954328e10 * np.power(1.0 + n, 9) + - 3.772650903e9 * np.power(1.0 + n, 10) + - 6.48395136e8 * np.power(1.0 + n, 11) + - 8.9565928e7 * np.power(1.0 + n, 12) + - 9.831528e6 * np.power(1.0 + n, 13) + - 840651.0 * np.power(1.0 + n, 14) + - 54144.0 * np.power(1.0 + n, 15) + - 2478.0 * np.power(1.0 + n, 16) + - 72.0 * np.power(1.0 + n, 17) + - 1.0 * np.power(1.0 + n, 18) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + - ( + 2.0 + * ( + 4.9589391456e10 + + 2.24271058032e11 * (1.0 + n) + + 4.7403095628e11 * np.power(1.0 + n, 2) + + 6.25731974284e11 * np.power(1.0 + n, 3) + + 5.81676555432e11 * np.power(1.0 + n, 4) + + 4.0689079961e11 * np.power(1.0 + n, 5) + + 2.23175026185e11 * np.power(1.0 + n, 6) + + 9.8520885539e10 * np.power(1.0 + n, 7) + + 3.554804558e10 * np.power(1.0 + n, 8) + + 1.0556408108e10 * np.power(1.0 + n, 9) + + 2.579863556e9 * np.power(1.0 + n, 10) + + 5.15736142e8 * np.power(1.0 + n, 11) + + 8.3361904e7 * np.power(1.0 + n, 12) + + 1.0703902e7 * np.power(1.0 + n, 13) + + 1.064065e6 * np.power(1.0 + n, 14) + + 78795.0 * np.power(1.0 + n, 15) + + 4084.0 * np.power(1.0 + n, 16) + + 132.0 * np.power(1.0 + n, 17) + + 2.0 * np.power(1.0 + n, 18) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -2.1114864e7 + - 6.3635712e7 * (1.0 + n) + - 8.634864e7 * np.power(1.0 + n, 2) + - 7.024968e7 * np.power(1.0 + n, 3) + - 3.8347981e7 * np.power(1.0 + n, 4) + - 1.4846592e7 * np.power(1.0 + n, 5) + - 4.190576e6 * np.power(1.0 + n, 6) + - 870720.0 * np.power(1.0 + n, 7) + - 132426.0 * np.power(1.0 + n, 8) + - 14400.0 * np.power(1.0 + n, 9) + - 1064.0 * np.power(1.0 + n, 10) + - 48.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -2.1114864e7 + - 6.3635712e7 * (1.0 + n) + - 8.634864e7 * np.power(1.0 + n, 2) + - 7.024968e7 * np.power(1.0 + n, 3) + - 3.8347981e7 * np.power(1.0 + n, 4) + - 1.4846592e7 * np.power(1.0 + n, 5) + - 4.190576e6 * np.power(1.0 + n, 6) + - 870720.0 * np.power(1.0 + n, 7) + - 132426.0 * np.power(1.0 + n, 8) + - 14400.0 * np.power(1.0 + n, 9) + - 1064.0 * np.power(1.0 + n, 10) + - 48.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + ) + ) + ) + / (8.0 + n) + + n + * ( + np.power(8.0 + n, -5) + - 0.8224670334241131 / np.power(8.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 7.0 + n)) / np.power(8.0 + n, 3) + + 0.419833592426477 / np.power(8.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 7.0 + n)) / np.power(8.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 8.0 + n)) / np.power(8.0 + n, 2) + - 0.3382260105347306 / (8.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 7.0 + n) + * ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + ) + / np.power(8.0 + n, 2) + - ( + 0.8224670334241131 + * np.power(-1.0, 8.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + ( + 3.0 + * ( + 148.0 + + 168.0 * (1.0 + n) + + 73.0 * np.power(1.0 + n, 2) + + 14.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + ) + ) + / np.power(8.0 + n, 2) + + ( + np.power(-1.0, 8.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 3.0 + * (7.0 + 2.0 * (1.0 + n)) + * ( + 20016.0 + + 47936.0 * (1.0 + n) + + 49184.0 * np.power(1.0 + n, 2) + + 28560.0 * np.power(1.0 + n, 3) + + 10321.0 * np.power(1.0 + n, 4) + + 2380.0 * np.power(1.0 + n, 5) + + 342.0 * np.power(1.0 + n, 6) + + 28.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + ) + ) + / np.power(8.0 + n, 3) + + ( + np.power(-1.0, 8.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + 9.0 + * ( + 3.7315776e7 + + 1.56477888e8 * (1.0 + n) + + 3.00572848e8 * np.power(1.0 + n, 2) + + 3.51218448e8 * np.power(1.0 + n, 3) + + 2.79551676e8 * np.power(1.0 + n, 4) + + 1.60708716e8 * np.power(1.0 + n, 5) + + 6.8959587e7 * np.power(1.0 + n, 6) + + 2.2477189e7 * np.power(1.0 + n, 7) + + 5.600212e6 * np.power(1.0 + n, 8) + + 1.062467e6 * np.power(1.0 + n, 9) + + 151200.0 * np.power(1.0 + n, 10) + + 15659.0 * np.power(1.0 + n, 11) + + 1116.0 * np.power(1.0 + n, 12) + + 49.0 * np.power(1.0 + n, 13) + + np.power(1.0 + n, 14) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + ( + ( + -2.69400384e8 + - 1.055773152e9 * (1.0 + n) + - 1.862215728e9 * np.power(1.0 + n, 2) + - 1.946883032e9 * np.power(1.0 + n, 3) + - 1.328424984e9 * np.power(1.0 + n, 4) + - 6.04538588e8 * np.power(1.0 + n, 5) + - 1.71139894e8 * np.power(1.0 + n, 6) + - 1.745252e7 * np.power(1.0 + n, 7) + + 8.746623e6 * np.power(1.0 + n, 8) + + 5.172041e6 * np.power(1.0 + n, 9) + + 1.470723e6 * np.power(1.0 + n, 10) + + 270665.0 * np.power(1.0 + n, 11) + + 33685.0 * np.power(1.0 + n, 12) + + 2759.0 * np.power(1.0 + n, 13) + + 135.0 * np.power(1.0 + n, 14) + + 3.0 * np.power(1.0 + n, 15) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 3.0 + * (7.0 + 2.0 * (1.0 + n)) + * ( + 20016.0 + + 47936.0 * (1.0 + n) + + 49184.0 * np.power(1.0 + n, 2) + + 28560.0 * np.power(1.0 + n, 3) + + 10321.0 * np.power(1.0 + n, 4) + + 2380.0 * np.power(1.0 + n, 5) + + 342.0 * np.power(1.0 + n, 6) + + 28.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 3.0 + * (7.0 + 2.0 * (1.0 + n)) + * ( + 20016.0 + + 47936.0 * (1.0 + n) + + 49184.0 * np.power(1.0 + n, 2) + + 28560.0 * np.power(1.0 + n, 3) + + 10321.0 * np.power(1.0 + n, 4) + + 2380.0 * np.power(1.0 + n, 5) + + 342.0 * np.power(1.0 + n, 6) + + 28.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + ) + ) + ) + / np.power(8.0 + n, 2) + ) + ) + - 0.019847559824380426 + * ( + -0.419833592426477 / (9.0 + n) + - (0.18119485915332012 * np.power(-1.0, 9.0 + n)) / (9.0 + n) + - (0.6010284515797971 * np.power(-1.0, 10.0 + n)) / (9.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 9.0 + n) + * ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + ) + / (9.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 10.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + ( + 4.0 + * ( + 6396.0 + + 9162.0 * (1.0 + n) + + 5473.0 * np.power(1.0 + n, 2) + + 1719.0 * np.power(1.0 + n, 3) + + 298.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + ) + ) + / (9.0 + n) + + ( + np.power(-1.0, 10.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + 4.0 + * ( + 1.4760576193536e13 + + 7.3798658489088e13 * (1.0 + n) + + 1.72837443710016e14 * np.power(1.0 + n, 2) + + 2.52453402491616e14 * np.power(1.0 + n, 3) + + 2.5828967175624e14 * np.power(1.0 + n, 4) + + 1.97032446481464e14 * np.power(1.0 + n, 5) + + 1.16425369498108e14 * np.power(1.0 + n, 6) + + 5.4627507667116e13 * np.power(1.0 + n, 7) + + 2.0690074606371e13 * np.power(1.0 + n, 8) + + 6.392775359655e12 * np.power(1.0 + n, 9) + + 1.621160332314e12 * np.power(1.0 + n, 10) + + 3.38175413478e11 * np.power(1.0 + n, 11) + + 5.7948536701e10 * np.power(1.0 + n, 12) + + 8.115008166e9 * np.power(1.0 + n, 13) + + 9.1986012e8 * np.power(1.0 + n, 14) + + 8.3116584e7 * np.power(1.0 + n, 15) + + 5.847213e6 * np.power(1.0 + n, 16) + + 308691.0 * np.power(1.0 + n, 17) + + 11506.0 * np.power(1.0 + n, 18) + + 270.0 * np.power(1.0 + n, 19) + + 3.0 * np.power(1.0 + n, 20) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + + ( + 2.0 + * ( + -2.3997963958272e13 + - 1.14129905965056e14 * (1.0 + n) + - 2.5222059905856e14 * np.power(1.0 + n, 2) + - 3.44033181492512e14 * np.power(1.0 + n, 3) + - 3.23935732772496e14 * np.power(1.0 + n, 4) + - 2.22502088875352e14 * np.power(1.0 + n, 5) + - 1.14348498644148e14 * np.power(1.0 + n, 6) + - 4.3968646592044e13 * np.power(1.0 + n, 7) + - 1.21438136977e13 * np.power(1.0 + n, 8) + - 2.010931672623e12 * np.power(1.0 + n, 9) + + 4.9482178305e10 * np.power(1.0 + n, 10) + + 1.59991878826e11 * np.power(1.0 + n, 11) + + 6.0723226806e10 * np.power(1.0 + n, 12) + + 1.4651858516e10 * np.power(1.0 + n, 13) + + 2.59766429e9 * np.power(1.0 + n, 14) + + 3.51680472e8 * np.power(1.0 + n, 15) + + 3.6575004e7 * np.power(1.0 + n, 16) + + 2.886025e6 * np.power(1.0 + n, 17) + + 167625.0 * np.power(1.0 + n, 18) + + 6770.0 * np.power(1.0 + n, 19) + + 170.0 * np.power(1.0 + n, 20) + + 2.0 * np.power(1.0 + n, 21) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3.6831936e7 + + 1.10670624e8 * (1.0 + n) + + 1.4936364e8 * np.power(1.0 + n, 2) + + 1.2041208e8 * np.power(1.0 + n, 3) + + 6.4783246e7 * np.power(1.0 + n, 4) + + 2.454111e7 * np.power(1.0 + n, 5) + + 6.715739e6 * np.power(1.0 + n, 6) + + 1.33785e6 * np.power(1.0 + n, 7) + + 192561.0 * np.power(1.0 + n, 8) + + 19530.0 * np.power(1.0 + n, 9) + + 1325.0 * np.power(1.0 + n, 10) + + 54.0 * np.power(1.0 + n, 11) + + np.power(1.0 + n, 12) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3.6831936e7 + + 1.10670624e8 * (1.0 + n) + + 1.4936364e8 * np.power(1.0 + n, 2) + + 1.2041208e8 * np.power(1.0 + n, 3) + + 6.4783246e7 * np.power(1.0 + n, 4) + + 2.454111e7 * np.power(1.0 + n, 5) + + 6.715739e6 * np.power(1.0 + n, 6) + + 1.33785e6 * np.power(1.0 + n, 7) + + 192561.0 * np.power(1.0 + n, 8) + + 19530.0 * np.power(1.0 + n, 9) + + 1325.0 * np.power(1.0 + n, 10) + + 54.0 * np.power(1.0 + n, 11) + + np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + ) + ) + ) + / (9.0 + n) + + n + * ( + np.power(9.0 + n, -5) + - 0.8224670334241131 / np.power(9.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 8.0 + n)) / np.power(9.0 + n, 3) + + 0.419833592426477 / np.power(9.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 8.0 + n)) / np.power(9.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 9.0 + n)) / np.power(9.0 + n, 2) + - 0.3382260105347306 / (9.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 8.0 + n) + * ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + ) + / np.power(9.0 + n, 2) + - ( + 0.8224670334241131 + * np.power(-1.0, 9.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * ( + -3828.0 + - 5736.0 * (1.0 + n) + - 3661.0 * np.power(1.0 + n, 2) + - 1248.0 * np.power(1.0 + n, 3) + - 238.0 * np.power(1.0 + n, 4) + - 24.0 * np.power(1.0 + n, 5) + - 1.0 * np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + ) + ) + / np.power(9.0 + n, 2) + + ( + np.power(-1.0, 9.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -2.1114864e7 + - 6.3635712e7 * (1.0 + n) + - 8.634864e7 * np.power(1.0 + n, 2) + - 7.024968e7 * np.power(1.0 + n, 3) + - 3.8347981e7 * np.power(1.0 + n, 4) + - 1.4846592e7 * np.power(1.0 + n, 5) + - 4.190576e6 * np.power(1.0 + n, 6) + - 870720.0 * np.power(1.0 + n, 7) + - 132426.0 * np.power(1.0 + n, 8) + - 14400.0 * np.power(1.0 + n, 9) + - 1064.0 * np.power(1.0 + n, 10) + - 48.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + ) + ) + / np.power(9.0 + n, 3) + + ( + np.power(-1.0, 9.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + - ( + 1.0 + * ( + -1.15567048512e11 + - 5.35159384704e11 * (1.0 + n) + - 1.151188217424e12 * np.power(1.0 + n, 2) + - 1.53078715296e12 * np.power(1.0 + n, 3) + - 1.412584727652e12 * np.power(1.0 + n, 4) + - 9.62381167416e11 * np.power(1.0 + n, 5) + - 5.02598549197e11 * np.power(1.0 + n, 6) + - 2.0609943264e11 * np.power(1.0 + n, 7) + - 6.7393018182e10 * np.power(1.0 + n, 8) + - 1.7735954328e10 * np.power(1.0 + n, 9) + - 3.772650903e9 * np.power(1.0 + n, 10) + - 6.48395136e8 * np.power(1.0 + n, 11) + - 8.9565928e7 * np.power(1.0 + n, 12) + - 9.831528e6 * np.power(1.0 + n, 13) + - 840651.0 * np.power(1.0 + n, 14) + - 54144.0 * np.power(1.0 + n, 15) + - 2478.0 * np.power(1.0 + n, 16) + - 72.0 * np.power(1.0 + n, 17) + - 1.0 * np.power(1.0 + n, 18) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + - ( + 2.0 + * ( + 4.9589391456e10 + + 2.24271058032e11 * (1.0 + n) + + 4.7403095628e11 * np.power(1.0 + n, 2) + + 6.25731974284e11 * np.power(1.0 + n, 3) + + 5.81676555432e11 * np.power(1.0 + n, 4) + + 4.0689079961e11 * np.power(1.0 + n, 5) + + 2.23175026185e11 * np.power(1.0 + n, 6) + + 9.8520885539e10 * np.power(1.0 + n, 7) + + 3.554804558e10 * np.power(1.0 + n, 8) + + 1.0556408108e10 * np.power(1.0 + n, 9) + + 2.579863556e9 * np.power(1.0 + n, 10) + + 5.15736142e8 * np.power(1.0 + n, 11) + + 8.3361904e7 * np.power(1.0 + n, 12) + + 1.0703902e7 * np.power(1.0 + n, 13) + + 1.064065e6 * np.power(1.0 + n, 14) + + 78795.0 * np.power(1.0 + n, 15) + + 4084.0 * np.power(1.0 + n, 16) + + 132.0 * np.power(1.0 + n, 17) + + 2.0 * np.power(1.0 + n, 18) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -2.1114864e7 + - 6.3635712e7 * (1.0 + n) + - 8.634864e7 * np.power(1.0 + n, 2) + - 7.024968e7 * np.power(1.0 + n, 3) + - 3.8347981e7 * np.power(1.0 + n, 4) + - 1.4846592e7 * np.power(1.0 + n, 5) + - 4.190576e6 * np.power(1.0 + n, 6) + - 870720.0 * np.power(1.0 + n, 7) + - 132426.0 * np.power(1.0 + n, 8) + - 14400.0 * np.power(1.0 + n, 9) + - 1064.0 * np.power(1.0 + n, 10) + - 48.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -2.1114864e7 + - 6.3635712e7 * (1.0 + n) + - 8.634864e7 * np.power(1.0 + n, 2) + - 7.024968e7 * np.power(1.0 + n, 3) + - 3.8347981e7 * np.power(1.0 + n, 4) + - 1.4846592e7 * np.power(1.0 + n, 5) + - 4.190576e6 * np.power(1.0 + n, 6) + - 870720.0 * np.power(1.0 + n, 7) + - 132426.0 * np.power(1.0 + n, 8) + - 14400.0 * np.power(1.0 + n, 9) + - 1064.0 * np.power(1.0 + n, 10) + - 48.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + ) + ) + ) + / np.power(9.0 + n, 2) + ) + ) + + 0.003243204652309423 + * ( + -0.419833592426477 / (10.0 + n) + - (0.18119485915332012 * np.power(-1.0, 10.0 + n)) / (10.0 + n) + - (0.6010284515797971 * np.power(-1.0, 11.0 + n)) / (10.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 10.0 + n) + * ( + 1 / (1.0 + n) + + ( + 3.0 + * ( + 342192.0 + + 781800.0 * (1.0 + n) + + 723680.0 * np.power(1.0 + n, 2) + + 359100.0 * np.power(1.0 + n, 3) + + 105455.0 * np.power(1.0 + n, 4) + + 18900.0 * np.power(1.0 + n, 5) + + 2030.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + ) + + S1 + ) + ) + / (10.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 11.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * ( + -270576.0 + - 465000.0 * (1.0 + n) + - 351800.0 * np.power(1.0 + n, 2) + - 151060.0 * np.power(1.0 + n, 3) + - 40053.0 * np.power(1.0 + n, 4) + - 6700.0 * np.power(1.0 + n, 5) + - 690.0 * np.power(1.0 + n, 6) + - 40.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + ) + ) + ) + / (10.0 + n) + + ( + np.power(-1.0, 11.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + ( + -3.665793851814298e16 + - 1.909490377752576e17 * (1.0 + n) + - 4.70862544109472e17 * np.power(1.0 + n, 2) + - 7.33980385029854e17 * np.power(1.0 + n, 3) + - 8.148989973914079e17 * np.power(1.0 + n, 4) + - 6.882981306584479e17 * np.power(1.0 + n, 5) + - 4.611713296031033e17 * np.power(1.0 + n, 6) + - 2.5219843129581005e17 * np.power(1.0 + n, 7) + - 1.14842783872951e17 * np.power(1.0 + n, 8) + - 4.415488009076552e16 * np.power(1.0 + n, 9) + - 1.44652124073368e16 * np.power(1.0 + n, 10) + - 4.05880131245378e15 * np.power(1.0 + n, 11) + - 9.77306344262685e14 * np.power(1.0 + n, 12) + - 2.01769269859842e14 * np.power(1.0 + n, 13) + - 3.560081466145e13 * np.power(1.0 + n, 14) + - 5.339127383592e12 * np.power(1.0 + n, 15) + - 6.75333270995e11 * np.power(1.0 + n, 16) + - 7.1298201266e10 * np.power(1.0 + n, 17) + - 6.19612062e9 * np.power(1.0 + n, 18) + - 4.34978004e8 * np.power(1.0 + n, 19) + - 2.4024499e7 * np.power(1.0 + n, 20) + - 1.00395e6 * np.power(1.0 + n, 21) + - 29810.0 * np.power(1.0 + n, 22) + - 560.0 * np.power(1.0 + n, 23) + - 5.0 * np.power(1.0 + n, 24) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + * np.power(10.0 + n, 3) + ) + - ( + 1.0 + * ( + -4.310738850111898e16 + - 2.300786211297024e17 * (1.0 + n) + - 5.793490942232486e17 * np.power(1.0 + n, 2) + - 9.169570554312557e17 * np.power(1.0 + n, 3) + - 1.0253555704764628e18 * np.power(1.0 + n, 4) + - 8.63111634551316e17 * np.power(1.0 + n, 5) + - 5.689117565311652e17 * np.power(1.0 + n, 6) + - 3.014933810188104e17 * np.power(1.0 + n, 7) + - 1.3085272169429526e17 * np.power(1.0 + n, 8) + - 4.712719391395e16 * np.power(1.0 + n, 9) + - 1.42167692592585e16 * np.power(1.0 + n, 10) + - 3.6154166212347e15 * np.power(1.0 + n, 11) + - 7.78200392291745e14 * np.power(1.0 + n, 12) + - 1.420469104479e14 * np.power(1.0 + n, 13) + - 2.198557186497e13 * np.power(1.0 + n, 14) + - 2.8791357052e12 * np.power(1.0 + n, 15) + - 3.17567574315e11 * np.power(1.0 + n, 16) + - 2.92849434e10 * np.power(1.0 + n, 17) + - 2.23273176e9 * np.power(1.0 + n, 18) + - 1.384419e8 * np.power(1.0 + n, 19) + - 6.812919e6 * np.power(1.0 + n, 20) + - 256300.0 * np.power(1.0 + n, 21) + - 6930.0 * np.power(1.0 + n, 22) + - 120.0 * np.power(1.0 + n, 23) + - 1.0 * np.power(1.0 + n, 24) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + * np.power(10.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -1.09027627776e11 + - 3.792865824e11 * (1.0 + n) + - 6.0713742384e11 * np.power(1.0 + n, 2) + - 5.9622705312e11 * np.power(1.0 + n, 3) + - 4.03242887656e11 * np.power(1.0 + n, 4) + - 1.99571643e11 * np.power(1.0 + n, 5) + - 7.48814979e10 * np.power(1.0 + n, 6) + - 2.175554084e10 * np.power(1.0 + n, 7) + - 4.951843521e9 * np.power(1.0 + n, 8) + - 8.86903e8 * np.power(1.0 + n, 9) + - 1.2470866e8 * np.power(1.0 + n, 10) + - 1.363476e7 * np.power(1.0 + n, 11) + - 1.137246e6 * np.power(1.0 + n, 12) + - 70000.0 * np.power(1.0 + n, 13) + - 3000.0 * np.power(1.0 + n, 14) + - 80.0 * np.power(1.0 + n, 15) + - 1.0 * np.power(1.0 + n, 16) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 3.0 + * ( + 342192.0 + + 781800.0 * (1.0 + n) + + 723680.0 * np.power(1.0 + n, 2) + + 359100.0 * np.power(1.0 + n, 3) + + 105455.0 * np.power(1.0 + n, 4) + + 18900.0 * np.power(1.0 + n, 5) + + 2030.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -1.09027627776e11 + - 3.792865824e11 * (1.0 + n) + - 6.0713742384e11 * np.power(1.0 + n, 2) + - 5.9622705312e11 * np.power(1.0 + n, 3) + - 4.03242887656e11 * np.power(1.0 + n, 4) + - 1.99571643e11 * np.power(1.0 + n, 5) + - 7.48814979e10 * np.power(1.0 + n, 6) + - 2.175554084e10 * np.power(1.0 + n, 7) + - 4.951843521e9 * np.power(1.0 + n, 8) + - 8.86903e8 * np.power(1.0 + n, 9) + - 1.2470866e8 * np.power(1.0 + n, 10) + - 1.363476e7 * np.power(1.0 + n, 11) + - 1.137246e6 * np.power(1.0 + n, 12) + - 70000.0 * np.power(1.0 + n, 13) + - 3000.0 * np.power(1.0 + n, 14) + - 80.0 * np.power(1.0 + n, 15) + - 1.0 * np.power(1.0 + n, 16) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + ) + ) + ) + ) + / (10.0 + n) + + n + * ( + np.power(10.0 + n, -5) + - 0.8224670334241131 / np.power(10.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 9.0 + n)) / np.power(10.0 + n, 3) + + 0.419833592426477 / np.power(10.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 9.0 + n)) / np.power(10.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 10.0 + n)) + / np.power(10.0 + n, 2) + - 0.3382260105347306 / (10.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 9.0 + n) + * ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + ) + / np.power(10.0 + n, 2) + - ( + 0.8224670334241131 + * np.power(-1.0, 10.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + ( + 4.0 + * ( + 6396.0 + + 9162.0 * (1.0 + n) + + 5473.0 * np.power(1.0 + n, 2) + + 1719.0 * np.power(1.0 + n, 3) + + 298.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + ) + ) + / np.power(10.0 + n, 2) + + ( + np.power(-1.0, 10.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3.6831936e7 + + 1.10670624e8 * (1.0 + n) + + 1.4936364e8 * np.power(1.0 + n, 2) + + 1.2041208e8 * np.power(1.0 + n, 3) + + 6.4783246e7 * np.power(1.0 + n, 4) + + 2.454111e7 * np.power(1.0 + n, 5) + + 6.715739e6 * np.power(1.0 + n, 6) + + 1.33785e6 * np.power(1.0 + n, 7) + + 192561.0 * np.power(1.0 + n, 8) + + 19530.0 * np.power(1.0 + n, 9) + + 1325.0 * np.power(1.0 + n, 10) + + 54.0 * np.power(1.0 + n, 11) + + np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + ) + ) + / np.power(10.0 + n, 3) + + ( + np.power(-1.0, 10.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + 4.0 + * ( + 1.4760576193536e13 + + 7.3798658489088e13 * (1.0 + n) + + 1.72837443710016e14 * np.power(1.0 + n, 2) + + 2.52453402491616e14 * np.power(1.0 + n, 3) + + 2.5828967175624e14 * np.power(1.0 + n, 4) + + 1.97032446481464e14 * np.power(1.0 + n, 5) + + 1.16425369498108e14 * np.power(1.0 + n, 6) + + 5.4627507667116e13 * np.power(1.0 + n, 7) + + 2.0690074606371e13 * np.power(1.0 + n, 8) + + 6.392775359655e12 * np.power(1.0 + n, 9) + + 1.621160332314e12 * np.power(1.0 + n, 10) + + 3.38175413478e11 * np.power(1.0 + n, 11) + + 5.7948536701e10 * np.power(1.0 + n, 12) + + 8.115008166e9 * np.power(1.0 + n, 13) + + 9.1986012e8 * np.power(1.0 + n, 14) + + 8.3116584e7 * np.power(1.0 + n, 15) + + 5.847213e6 * np.power(1.0 + n, 16) + + 308691.0 * np.power(1.0 + n, 17) + + 11506.0 * np.power(1.0 + n, 18) + + 270.0 * np.power(1.0 + n, 19) + + 3.0 * np.power(1.0 + n, 20) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + + ( + 2.0 + * ( + -2.3997963958272e13 + - 1.14129905965056e14 * (1.0 + n) + - 2.5222059905856e14 * np.power(1.0 + n, 2) + - 3.44033181492512e14 * np.power(1.0 + n, 3) + - 3.23935732772496e14 * np.power(1.0 + n, 4) + - 2.22502088875352e14 * np.power(1.0 + n, 5) + - 1.14348498644148e14 * np.power(1.0 + n, 6) + - 4.3968646592044e13 * np.power(1.0 + n, 7) + - 1.21438136977e13 * np.power(1.0 + n, 8) + - 2.010931672623e12 * np.power(1.0 + n, 9) + + 4.9482178305e10 * np.power(1.0 + n, 10) + + 1.59991878826e11 * np.power(1.0 + n, 11) + + 6.0723226806e10 * np.power(1.0 + n, 12) + + 1.4651858516e10 * np.power(1.0 + n, 13) + + 2.59766429e9 * np.power(1.0 + n, 14) + + 3.51680472e8 * np.power(1.0 + n, 15) + + 3.6575004e7 * np.power(1.0 + n, 16) + + 2.886025e6 * np.power(1.0 + n, 17) + + 167625.0 * np.power(1.0 + n, 18) + + 6770.0 * np.power(1.0 + n, 19) + + 170.0 * np.power(1.0 + n, 20) + + 2.0 * np.power(1.0 + n, 21) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3.6831936e7 + + 1.10670624e8 * (1.0 + n) + + 1.4936364e8 * np.power(1.0 + n, 2) + + 1.2041208e8 * np.power(1.0 + n, 3) + + 6.4783246e7 * np.power(1.0 + n, 4) + + 2.454111e7 * np.power(1.0 + n, 5) + + 6.715739e6 * np.power(1.0 + n, 6) + + 1.33785e6 * np.power(1.0 + n, 7) + + 192561.0 * np.power(1.0 + n, 8) + + 19530.0 * np.power(1.0 + n, 9) + + 1325.0 * np.power(1.0 + n, 10) + + 54.0 * np.power(1.0 + n, 11) + + np.power(1.0 + n, 12) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3.6831936e7 + + 1.10670624e8 * (1.0 + n) + + 1.4936364e8 * np.power(1.0 + n, 2) + + 1.2041208e8 * np.power(1.0 + n, 3) + + 6.4783246e7 * np.power(1.0 + n, 4) + + 2.454111e7 * np.power(1.0 + n, 5) + + 6.715739e6 * np.power(1.0 + n, 6) + + 1.33785e6 * np.power(1.0 + n, 7) + + 192561.0 * np.power(1.0 + n, 8) + + 19530.0 * np.power(1.0 + n, 9) + + 1325.0 * np.power(1.0 + n, 10) + + 54.0 * np.power(1.0 + n, 11) + + np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + ) + ) + ) + / np.power(10.0 + n, 2) + ) + ) + ) + + +@nb.njit("c16(c16,c16,c16)", cache=True) +def F13(n, S1, S2): + return ( + -0.15312792746068732 * n + + (0.13621083778040208 * n) / (2.0 + n) + - (0.474631789932249 * n) / (3.0 + n) + + (0.24528438212633397 * n) / (4.0 + n) + - (0.26580874921126374 * n) / (5.0 + n) + + (1.2217722976683179 * n) / (6.0 + n) + - (3.6324293738026023 * n) / (7.0 + n) + + (7.4838836775956015 * n) / (8.0 + n) + - (10.706375063797914 * n) / (9.0 + n) + + (10.449787985527623 * n) / (10.0 + n) + - (6.649468393739114 * n) / (11.0 + n) + + (2.4904695902320904 * n) / (12.0 + n) + - (0.41762920477450316 * n) / (13.0 + n) + - 0.2720646169555415 * (-1.0 + 1 / (1.0 + n)) + - 0.0030864197530864196 + * n + * ( + -49.613452021037574 + + 1695.6636939202713 / (1.0 + n) + + 297.65017554444273 / (2.0 + n) + - 53.043164791285136 / (3.0 + n) + + (280.1816714156928 * (1.0 + (1.0 + n) * S1)) / np.power(1.0 + n, 2) + + (566.2149227313704 * (1.0 + (2.0 + n) * (1 / (1.0 + n) + S1))) + / np.power(2.0 + n, 2) + - ( + 115.5647471869277 + * (1.0 + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) + ) + / np.power(3.0 + n, 2) + - ( + 1607.5136662661575 + * ( + 1.0 + + n + * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) + ) + ) + / np.power(n, 2) + + ( + 972.0 + * ( + 1.0 + + (2.0 + n) * (1 / (1.0 + n) + S1) + + np.power(2.0 + n, 2) + * ( + np.power(1.0 + n, -2) + + S1 / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + ) + / np.power(2.0 + n, 3) + - ( + 1296.0 + * ( + 1.0 + + (1.0 + n) * S1 + + np.power(1.0 + n, 2) + * ( + np.power(1.0 + n, -2) + + S1 / (1.0 + n) + - (1.0 * (1 / (1.0 + n) + S1)) / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + ) + / np.power(1.0 + n, 3) + - ( + 216.0 + * ( + 1.0 + + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + + np.power(3.0 + n, 2) + * ( + np.power(1.0 + n, -2) + + np.power(2.0 + n, -2) + + S1 / (1.0 + n) + + (1 / (1.0 + n) + S1) / (2.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + ) + / np.power(3.0 + n, 3) + + ( + 540.0 + * ( + 1.0 + + n + * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) + + np.power(n, 2) + * ( + np.power(1.0 + n, -2) + + 1 / (n * (1.0 + n)) + + S1 / (1.0 + n) + + ((1.0 - 2.0 * (1.0 + n)) * (1 / (1.0 + n) + S1)) + / (n * (1.0 + n)) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + ) + / np.power(n, 3) + ) + ) diff --git a/src/eko/matching_conditions/n3lo/g_functions.py b/src/eko/matching_conditions/n3lo/g_functions.py new file mode 100644 index 000000000..f25b8e85a --- /dev/null +++ b/src/eko/matching_conditions/n3lo/g_functions.py @@ -0,0 +1,320 @@ +import numpy as np +import numba as nb + +from ...anomalous_dimensions.harmonics import ( + cern_polygamma, + harmonic_S1, + harmonic_S2, + harmonic_S3, +) +from ...anomalous_dimensions.harmonics import zeta2, zeta3 + +a1 = np.array( + [ + 0.999999974532238, + -0.499995525889840, + 0.333203435557262, + -0.248529457782640, + 0.191451164719161, + -0.137466222728331, + 0.0792107412244877, + -0.0301109656912626, + 0.00538406208663153, + 0.0000001349586745, + ] +) + +c1 = np.array( + [ + 2.2012182965269744e-8, + 2.833327652357064, + -1.8330909624101532, + 0.7181879191200942, + -0.0280403220046588, + -0.181869786537805, + 0.532318519269331, + -1.07281686995035, + 1.38194913357518, + -1.11100841298484, + 0.506649587198046, + -0.100672390783659, + ] +) + +c3 = np.array( + [ + 0, + 1.423616247405256, + -0.08001203559240111, + -0.39875367195395994, + 0.339241791547134, + -0.0522116678353452, + -0.0648354706049337, + 0.0644165053822532, + -0.0394927322542075, + 0.0100879370657869, + ] +) + +p11 = np.array([11.0 / 6.0, -3.0, 3.0 / 2.0, -1.0 / 3.0]) +p32 = np.array([-25.0 / 24.0, 2.0, -3.0 / 2.0, 2.0 / 3.0, -1.0 / 8.0]) +p31 = np.array([205.0 / 144.0, -25.0 / 12.0, 23.0 / 24.0, -13.0 / 36.0, 1.0 / 16]) + + +@nb.njit("c16(c16)", cache=True) +def mellin_g4(N): + r""" + Computes the Mellin transform of :math:`\text{Li}_2(-x)/(1+x)`. + + Implementation and defition in B.5.25 of :cite:`MuselliPhD` or + in eq 61 of :cite:`Bl_mlein_2000`, but none of them is fully correct. + + + Parameters + ---------- + N : complex + Mellin moment + + Returns + ------- + mellin_g4 : complex + Mellin transform :math:`\mathcal{M}[\text{Li}_2(-x)/(1+x)](N)` + """ + g4 = -1 / 2 * zeta2 * np.log(2) + for k, ak in enumerate(a1): + Nk = N + k + 1 + beta = 1 / 2 * (harmonic_S1((Nk) / 2) - harmonic_S1((Nk - 1) / 2)) + g4 += ak * (N / Nk * zeta2 / 2 + (k + 1) / Nk ** 2 * (np.log(2) - beta)) + return g4 + + +@nb.njit("c16(c16)", cache=True) +def mellin_g5(N): + r""" + Computes the Mellin transform of :math:`(\text{Li}_2(x)ln(x))/(1+x)`. + + Implementation and defition in B.5.26 of :cite:`MuselliPhD` or + in eq 62 of :cite:`Bl_mlein_2000`, but none of them is fully correct. + + Parameters + ---------- + N : complex + Mellin moment + + Returns + ------- + mellin_g5 : complex + Mellin transform :math:`\mathcal{M}[(\text{Li}_2(x)ln(x))/(1+x)](N)` + """ + g5 = 0.0 + for k, ak in enumerate(a1): + Nk = N + k + 1 + g5 -= ak * ( + (k + 1) + / Nk ** 2 + * (zeta2 + cern_polygamma(Nk + 1, 1) - 2 * harmonic_S1(Nk) / Nk) + ) + return g5 + + +@nb.njit("c16(c16)", cache=True) +def mellin_g6(N): + r""" + Computes the Mellin transform of :math:`\text{Li}_3(x)/(1+x)`. + + Implementation and defition in B.5.27 of :cite:`MuselliPhD` or + in eq 63 of :cite:`Bl_mlein_2000`, but none of them is fully correct. + + Parameters + ---------- + N : complex + Mellin moment + + Returns + ------- + mellin_g6 : complex + Mellin transform :math:`\mathcal{M}[\text{Li}_3(x)/(1+x)](N)` + + + """ + g6 = zeta3 * np.log(2) + for k, ak in enumerate(a1): + Nk = N + k + 1 + g6 -= ak * (N / Nk * zeta3 + (k + 1) / Nk ** 2 * (zeta2 - harmonic_S1(Nk) / Nk)) + return g6 + + +@nb.njit("c16(c16)", cache=True) +def mellin_g8(N): + r""" + Computes the Mellin transform of :math:`S_{1,2}(x)/(1+x)`. + + Implementation and defition in B.5.29 of :cite:`MuselliPhD` or + in eq 65 of :cite:`Bl_mlein_2000`, but none of them is fully correct. + + Parameters + ---------- + N : complex + Mellin moment + + Returns + ------- + mellin_g8 : complex + Mellin transform :math:`\mathcal{M}[S_{1,2}(x)/(1+x)](N)` + """ + g8 = zeta3 * np.log(2) + for k, ak in enumerate(a1): + Nk = N + k + 1 + g8 -= ak * ( + N / Nk * zeta3 + + (k + 1) / Nk ** 2 * 1 / 2 * (harmonic_S1(Nk) ** 2 + harmonic_S2(Nk)) + ) + return g8 + + +@nb.njit("c16(c16,c16,c16)", cache=True) +def mellin_g18(N, S1, S2): + r""" + Computes the Mellin transform of :math:`-(\text{Li}_2(x) - \zeta_2)/(1-x)`. + + Implementation and defition in eq 124 of :cite:`Bl_mlein_2000` + + Note: comparing to :cite:`Bl_mlein_2000`, we believe :cite:`MuselliPhD` + was not changing the notations of :math:`P^{(1)}_{2}` to :math:`P^{(1)}_{1}`. + So we implement eq 124 of :cite:`Bl_mlein_2000` but using :cite:`MuselliPhD` + notation. + + Parametersrrr + ---------- + N : complex + Mellin moment + S1 : complex + harmonics.harmonic_S1(N) + S2 : complex + harmonics.harmonic_S2(N) + Returns + ------- + mellin_g18 : complex + Mellin transform :math:`\mathcal{M}[-(\text{Li}_2(x) - \zeta_2)/(1-x)](N)` + """ + g18 = (S1 ** 2 + S2) / (N) - zeta2 * S1 + for k, ck in enumerate(c1): + Nk = N + k + g18 += ck * (N) / (Nk) * harmonic_S1(Nk) + for k, p11k in enumerate(p11): + Nk = N + k + g18 -= p11k * (N) / (Nk) * (harmonic_S1(Nk) ** 2 + harmonic_S2(Nk)) + return g18 + + +@nb.njit("c16(c16,c16)", cache=True) +def mellin_g19(N, S1): + r""" + Computes the Mellin transform of :math:`-(\text{Li}_2(-x) + \zeta_2/2)/(1-x)`. + + Implementation and defition in B.5.40 of :cite:`MuselliPhD` or in 125 of + :cite:`Bl_mlein_2000`, but none of them is fully correct. + + Parameters + ---------- + N : complex + Mellin moment + S1 : complex + harmonics.harmonic_S1(N) + + Returns + ------- + mellin_g19 : complex + Mellin transform :math:`\mathcal{M}[-(\text{Li}_2(-x) + \zeta_2/2)/(1-x)](N)` + """ + g19 = 1 / 2 * zeta2 * S1 + for k, ak in enumerate(a1): + Nk = N + k + g19 -= ak / (k + 1) * harmonic_S1(Nk + 1) + return g19 + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def mellin_g21(N, S1, S2, S3): + r""" + Computes the Mellin transform of :math:`-(S_{1,2}(x) - \zeta_3)/(1-x)`. + + Implementation and defition in B.5.42 of :cite:`MuselliPhD` + + Note: comparing to :cite:`Bl_mlein_2000`, we believe :cite:`MuselliPhD` + was not changing the notations of :math:`P^{(3)}_{2}` to :math:`P^{(3)}_{1}` + and :math:`P^{(3)}_{3}` to :math:`P^{(3)}_{2}`. + So we implement eq 127 of :cite:`Bl_mlein_2000` but using :cite:`MuselliPhD` + notation. + + Parameters + ---------- + N : complex + Mellin moment + S1 : complex + harmonics.harmonic_S1(N) + S2 : complex + harmonics.harmonic_S2(N) + S3 : complex + harmonics.harmonic_S3(N) + + Returns + ------- + mellin_g21 : complex + Mellin transform :math:`\mathcal{M}[-(S_{1,2}(x) - \zeta_3)/(1-x)](N)` + """ + g21 = -zeta3 * S1 + (S1 ** 3 + 3 * S1 * S2 + 2 * S3) / (2 * N) + for k, ck in enumerate(c3): + Nk = N + k + g21 += ck * N / Nk * harmonic_S1(Nk) + for k in range(0, 5): + Nk = N + k + g21 += ( + N + / Nk + * ( + p32[k] + * ( + harmonic_S1(Nk) ** 3 + + 3 * harmonic_S1(Nk) * harmonic_S2(Nk) + + 2 * harmonic_S3(Nk) + ) + - p31[k] * (harmonic_S1(Nk) ** 2 + harmonic_S2(Nk)) + ) + ) + return g21 + + +@nb.njit("c16(c16)", cache=True) +def mellin_g22(N): + r""" + Computes the Mellin transform of :math:`-(\text{Li}_2(x) ln(x))/(1-x)`. + + Implementation and defition in B.5.43 of :cite:`MuselliPhD` + + Note: comparing to :cite:`Bl_mlein_2000`, we believe :cite:`MuselliPhD` + was not changing the notations of :math:`P^{(1)}_{2}` to :math:`P^{(1)}_{1}` + So we implement eq 128 of :cite:`Bl_mlein_2000` but using :cite:`MuselliPhD` + notation. + + Parameters + ---------- + N : complex + Mellin moment + + Returns + ------- + mellin_g22 : complex + Mellin transform :math:`\mathcal{M}[-(\text{Li}_2(x) ln(x))/(1-x)](N)` + """ + g22 = 0.0 + for k, ck in enumerate(c1): + Nk = N + k + g22 += ck * cern_polygamma(Nk + 1, 1) + for k, p11k in enumerate(p11): + Nk = N + k + g22 -= p11k * ( + harmonic_S1(Nk) * cern_polygamma(Nk + 1, 1) + - 1 / 2 * cern_polygamma(Nk + 1, 2) + ) + return g22 diff --git a/src/eko/matching_conditions/n3lo/s_functions.py b/src/eko/matching_conditions/n3lo/s_functions.py new file mode 100644 index 000000000..658dddd71 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/s_functions.py @@ -0,0 +1,71 @@ +# -*- coding: utf-8 -*- +""" +This module contains some additional harmonics sum. +Defintion are coming from :cite:`MuselliPhD,Bl_mlein_2009` +""" +import numpy as np +import numba as nb + +from eko.anomalous_dimensions import harmonics +from . import g_functions as gf + +zeta2 = harmonics.zeta2 +zeta3 = harmonics.zeta3 + +li4half = 0.517479 +log2 = np.log(2) + + +@nb.njit("c16(c16,c16)", cache=True) +def harmonic_Sm1(N, Sp1): + return (-1) ** N / 2 * (Sp1 - harmonics.harmonic_S1((N - 1) / 2)) - log2 + + +@nb.njit("c16(c16,c16)", cache=True) +def harmonic_Sm2(N, Sp2): + return (-1) ** N / 4 * (Sp2 - harmonics.harmonic_S2((N - 1) / 2)) - zeta2 / 2 + + +@nb.njit("c16(c16,c16)", cache=True) +def harmonic_Sm3(N, Sp3): + return (-1) ** N / 8 * (Sp3 - harmonics.harmonic_S3((N - 1) / 2)) - 3 / 4 * zeta3 + + +@nb.njit("c16(c16,c16,c16)", cache=True) +def harmonic_S21(N, S1, S2): + return -gf.mellin_g18(N, S1, S2) + 2 * zeta3 + + +@nb.njit("c16(c16,c16)", cache=True) +def harmonic_Sm21(N, Sm1): + # Note Mellin G3 was integrated following x^(N-1) convention. + return ( + -((-1) ** N) * harmonics.mellin_g3(N + 1) + + zeta2 * Sm1 + - 5 / 8 * zeta3 + + zeta2 * log2 + ) + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def harmonic_S2m1(N, S2, Sm1, Sm2): + return ( + -((-1) ** N) * gf.mellin_g4(N) + - np.log(2) * (S2 - Sm2) + - 1 / 2 * zeta2 * Sm1 + + 1 / 4 * zeta3 + - 1 / 2 * zeta2 * log2 + ) + + +# def harmonic_Sm31(N,Sm1,Sm2): +# return ( +# (-1) ** N * gf.mellin_g6(N) +# + zeta2 * Sm2 +# - zeta3 * Sm1 +# - 3 / 5 * zeta2 ** 2 +# + 2 * li4half +# + 3 / 4 * zeta3 * log2 +# - 1 / 2 * zeta2 * log2 ** 2 +# + 1 / 12 * log2 ** 4 +# ) diff --git a/tests/test_f_functions.py b/tests/test_f_functions.py new file mode 100644 index 000000000..c5269d4b0 --- /dev/null +++ b/tests/test_f_functions.py @@ -0,0 +1,142 @@ +# -*- coding: utf-8 -*- +# Test G functions impleeted by muselli PhD + +import numpy as np + +from eko.anomalous_dimensions import harmonics +import eko.matching_conditions.n3lo.f_functions as f +import eko.matching_conditions.n3lo.s_functions as sf + +zeta2 = harmonics.zeta2 +zeta3 = harmonics.zeta3 +zeta4 = harmonics.zeta4 + +log2 = np.log(2) + +# reference values coming fom mathematica +testN = [1, 2, 2 + 2j, 10 + 5j, 100] +refvals = { + "S41": [1.0, 1.09375, 1.13674 + 0.0223259j, 1.13322 + 0.000675408j, 1.13348], + "S21m2": [ + -1.0 + 2.32792e-17, + -1.34375 - 5.19668e-18j, + -1.55003 - 0.349276j, + -1.96639 - 0.100789j, + -2.19769, + ], + "S221": [1, 1.34375, 1.5542 + 0.326975j, 1.89896 + 0.0770909j, 2.05026], + "Sm221": [ + -1.0, + -0.65625, + -0.767023 - 0.000133792j, + -0.767089 - 8.56713e-10j, + -0.766973, + ], + "S311": [1.0, 1.21875, 1.35078 + 0.142143j, 1.43773 + 0.0168713j, 1.45799], + "S2111": [1.0, 1.46875, 1.71628 + 0.591696j, 2.70015 + 0.291842j, 3.66588], + "Sm2111": [ + -1.0, + -0.53125, + -0.705997 - 0.000177561j, + -0.706186 - 2.32698e-9j, + -0.704801, + ], + 'Sm21': [-1., -0.625, -0.751192 - 0.000147181j, -0.751286 - 1.17067e-9j, -0.751029] +} + + +# copare the exact values of some harmonics +# All the harmonics defition are coming from :cite`:Bl_mlein_2009` section 9. +def test_F9(): + for N, vals in zip(testN, refvals["S41"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + S3 = harmonics.harmonic_S3(N) + S41 = -f.F9(N, S1) + S1 * zeta4 - S2 * zeta3 + S3 * zeta2 + np.testing.assert_allclose(S41, vals, atol=1e-05) + + +def test_F11(): + for N, vals in zip(testN, refvals["S311"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + S311 = f.F11(N, S1, S2) + zeta3 * S2 - zeta4 / 4 * S1 + np.testing.assert_allclose(S311, vals, atol=1e-05) + + +def test_F13(): + for N, vals in zip(testN, refvals["S221"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + S21 = sf.harmonic_S21(N, S1, S2) + S221 = ( + -2 * f.F11(N, S1, S2) + + 1 / 2 * f.F13(N, S1, S2) + + zeta2 * S21 + - 3 / 10 * zeta2 ** 2 * S1 + ) + np.testing.assert_allclose(S221, vals, atol=1e-05) + + +def test_F12_F14(): + # here there is a typo in eq (9.25) of Bl_mlein_2009 + for N, vals in zip(testN, refvals["Sm221"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N / 2)) + S21 = sf.harmonic_S21(N, S1, S2) + Sm21 = sf.harmonic_Sm21(N, Sm1) + Sm221 = ( + (-1) ** (N + 1) * (2 * f.F12(N, S1, S2) - 1 / 2 * f.F14(N, S1, S2, S21)) + + zeta2 * Sm21 + - 3 / 10 * zeta2 ** 2 * Sm1 + - 0.119102 + 0.0251709 + ) + np.testing.assert_allclose(Sm221, vals, atol=1e-05) + +def test_F16(): + for N, vals in zip(testN, refvals["S21m2"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N / 2)) + Sm2 = sf.harmonic_Sm2(N, harmonics.harmonic_S2(N / 2)) + Sm3 = sf.harmonic_Sm3(N, harmonics.harmonic_S3(N / 2)) + S21 = sf.harmonic_S21(N, S1, S2) + S2m1 = sf.harmonic_S2m1(N, S2, Sm1, Sm2) + Sm21 = sf.harmonic_Sm21(N, Sm1) + S21m2 = ( + (-1) ** (N) * f.F16(N, S1, Sm1, Sm2, Sm3, Sm21) + - 1 / 2 * zeta2 * (S21 - S2m1) + - (1 / 8 * zeta3 - 1 / 2 * zeta2 * log2) * (S2 - Sm2) + + 1 / 8 * zeta2 ** 2 * Sm1 + + 0.0854806 + ) + np.testing.assert_allclose(S21m2, vals, atol=1e-04) + +def test_F17(): + for N, vals in zip(testN, refvals["S2111"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + S3 = harmonics.harmonic_S3(N) + S2111 = -f.F17(N, S1, S2, S3) + zeta4 * S1 + np.testing.assert_allclose(S2111, vals, atol=1e-05) + + +def test_F18(): + for N, vals in zip(testN, refvals["Sm2111"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + S3 = harmonics.harmonic_S3(N) + Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N / 2)) + Sm2111 = ( + (-1) ** (N + 1) * f.F18(N, S1, S2, S3) + + zeta4 * Sm1 + - 0.706186 + + 0.693147 * zeta4 + ) + np.testing.assert_allclose(Sm2111, vals, atol=1e-05) + +def test_Sm21(): + for N, vals in zip(testN, refvals["Sm21"]): + Sm1 = sf.harmonic_Sm1(N,harmonics.harmonic_S1(N / 2)) + np.testing.assert_allclose(sf.harmonic_Sm21(N, Sm1), vals, atol=1e-05) diff --git a/tests/test_g_functions.py b/tests/test_g_functions.py new file mode 100644 index 000000000..19d2a7da5 --- /dev/null +++ b/tests/test_g_functions.py @@ -0,0 +1,129 @@ +# -*- coding: utf-8 -*- +# Test G functions impleeted by muselli PhD + +import numpy as np + +from eko.anomalous_dimensions import harmonics +import eko.matching_conditions.n3lo.g_functions as gf +import eko.matching_conditions.n3lo.s_functions as sf + +zeta2 = harmonics.zeta2 +zeta3 = harmonics.zeta3 + +li4half = 0.517479 +li5half = 0.508401 +log2 = np.log(2) + + +testN = [1, 10, 100] + + +def harmonic_Sm31(N): + Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N/2)) + Sm2 = sf.harmonic_Sm2(N, harmonics.harmonic_S2(N/2)) + return ( + (-1) ** N * gf.mellin_g6(N) + + zeta2 * Sm2 + - zeta3 * Sm1 + - 3 / 5 * zeta2 ** 2 + + 2 * li4half + + 3 / 4 * zeta3 * log2 + - 1 / 2 * zeta2 * log2 ** 2 + + 1 / 12 * log2 ** 4 + ) + + +# copare the exact values of some harmonics with Muselli parametrisations +def test_g4(): + refvals = [-1, -1.34359, -1.40286] + for N, vals in zip(testN, refvals): + S2 = harmonics.harmonic_S2(N) + Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N/2)) + Sm2 = sf.harmonic_Sm2(N, harmonics.harmonic_S2(N/2)) + S2m1 = sf.harmonic_S2m1(N, S2, Sm1, Sm2) + np.testing.assert_allclose(S2m1, vals, atol=1e-05) + + +def test_g6(): + refvals = [-1, -0.857976, -0.859245] + for N, vals in zip(testN, refvals): + + Sm31 = harmonic_Sm31(N) + np.testing.assert_allclose(Sm31, vals, atol=1e-05) + + +def test_g5(): + refvals = [-1, -0.777375, -0.784297] + for N, vals in zip(testN, refvals): + Sm31 = harmonic_Sm31(N) + Sm22 = ( + (-1) ** N * gf.mellin_g5(N) + - 2 * Sm31 + + 2 * zeta2 * sf.harmonic_Sm2(N, harmonics.harmonic_S2(N/2)) + + 3 / 40 * zeta2 ** 2 + ) + np.testing.assert_allclose(Sm22, vals, atol=1e-05) + + +def test_g8(): + refvals = [-1, -0.696836, -0.719637] + for N, vals in zip(testN, refvals): + Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N/2)) + Sm211 = ( + -((-1) ** N) * gf.mellin_g8(N) + + zeta3 * Sm1 + - li4half + + 1 / 8 * zeta2 ** 2 + + 1 / 8 * zeta3 * log2 + + 1 / 4 * zeta2 * log2 ** 2 + - 1 / 24 * log2 ** 4 + ) + np.testing.assert_allclose(Sm211, vals, atol=1e-05) + + +def test_g18(): + testN = [1, 2, 3, 10, 100] + refvals = [1, 1.375, 1.5787, 2.0279, 2.34252] + for N, vals in zip(testN, refvals): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + S21 = sf.harmonic_S21(N, S1, S2) + np.testing.assert_allclose(S21, vals, atol=1e-05) + + +def test_g19(): + refvals = [1, 0.953673, 0.958928] + for N, vals in zip(testN, refvals): + S1 = harmonics.harmonic_S1(N) + Sm2m1 = ( + -gf.mellin_g19(N, S1) + + log2 * (harmonics.harmonic_S2(N) - sf.harmonic_Sm2(N, harmonics.harmonic_S2(N/2))) + - 5 / 8 * zeta3 + ) + np.testing.assert_allclose(Sm2m1, vals, atol=1e-05) + + +def test_g21(): + testN = [1, 2, 3, 10, 100] + refvals = [1, 1.4375, 1.69985, 2.38081, 3.04323] + for N, vals in zip(testN, refvals): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + S3 = harmonics.harmonic_S3(N) + S211 = -gf.mellin_g21(N, S1, S2, S3) + 6 / 5 * zeta2 ** 2 + np.testing.assert_allclose(S211, vals, atol=1e-05) + + +def test_g22(): + testN = [1, 2, 3, 10, 100] + refvals = [1, 1.1875, 1.2554, 1.33724, 1.35262] + for N, vals in zip(testN, refvals): + S2 = harmonics.harmonic_S2(N) + S31 = ( + 1 / 2 * gf.mellin_g22(N) + - 1 / 4 * harmonics.harmonic_S4(N) + - 1 / 4 * S2 ** 2 + + zeta2 * S2 + - 3 / 20 * zeta2 ** 2 + ) + np.testing.assert_allclose(S31, vals, atol=1e-05) From 398946b521a9af462588103d2c67312fba3817e8 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Sun, 26 Sep 2021 20:57:33 +0200 Subject: [PATCH 32/71] cache harmonics, add F19,F20,F21, more tests --- .../matching_conditions/n3lo/f_functions.py | 169 ++++++++++++++++ .../matching_conditions/n3lo/s_functions.py | 191 ++++++++++++++++-- tests/test_ad_harmonics.py | 4 +- tests/test_f_functions.py | 98 +++++---- tests/test_g_functions.py | 70 ++----- tests/test_matching_nnlo.py | 4 +- tests/test_s_functions.py | 60 ++++++ 7 files changed, 478 insertions(+), 118 deletions(-) create mode 100644 tests/test_s_functions.py diff --git a/src/eko/matching_conditions/n3lo/f_functions.py b/src/eko/matching_conditions/n3lo/f_functions.py index b7b4f7be5..58361782d 100644 --- a/src/eko/matching_conditions/n3lo/f_functions.py +++ b/src/eko/matching_conditions/n3lo/f_functions.py @@ -8546,3 +8546,172 @@ def F13(n, S1, S2): / np.power(n, 3) ) ) + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def F19(n, S1, S2, S3): + return ( + 7.548974594558902 + - 1.5497677311665408 / np.power(1.0 + n, 3) + - 0.5497677311665407 / np.power(2.0 + n, 3) + + 2.0 / np.power(2.0 + n, 2) + - 11.975319856741933 / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - (14.370383828090318 * n) / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - (4.790127942696773 * np.power(n, 2)) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + 3.0 / (2.0 + n) + - 9.738329251443808 / ((1.0 + n) * (2.0 + n)) + - (6.492219500962539 * n) / ((1.0 + n) * (2.0 + n)) + - 0.2997677311665407 / np.power(3.0 + n, 3) + - 0.1450639713483865 / np.power(3.0 + n, 2) + - 0.05860975048126964 / (3.0 + n) + - 0.18865662005542957 / np.power(4.0 + n, 3) + - 0.07098989727431243 / np.power(4.0 + n, 2) + - 0.021572713444232602 / (4.0 + n) + - 0.12615662005542957 / np.power(5.0 + n, 3) + - 0.03973989727431243 / np.power(5.0 + n, 2) + - 0.009853963444232604 / (5.0 + n) + - 0.08615662005542958 / np.power(6.0 + n, 3) + - 0.02373989727431243 / np.power(6.0 + n, 2) + - 0.005053963444232604 / (6.0 + n) + - 0.058378842277651805 / np.power(7.0 + n, 3) + - 0.01448063801505317 / np.power(7.0 + n, 2) + - 0.0027391486294177886 / (7.0 + n) + - 0.03797067901234568 / np.power(8.0 + n, 3) + - 0.008649734224965707 / np.power(8.0 + n, 2) + - 0.0014896692458276177 / (8.0 + n) + - 0.02234567901234568 / np.power(9.0 + n, 3) + - 0.004743484224965707 / np.power(9.0 + n, 2) + - 0.0007572473708276177 / (9.0 + n) + - 0.01 / np.power(10.0 + n, 3) + - 0.002 / np.power(10.0 + n, 2) + - 0.0003 / (10.0 + n) + - 3.2461097504812697 * S1 + - 2.3950639713483866 * S2 + - (1.5497677311665408 * S3) / np.power(1.0 + n, 3) + - (4.649303193499622 * n * S3) / np.power(1.0 + n, 3) + - (4.649303193499622 * np.power(n, 2) * S3) / np.power(1.0 + n, 3) + - (1.5497677311665408 * np.power(n, 3) * S3) / np.power(1.0 + n, 3) + ) + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def F21(n, Sm1, Sm2, Sm3): + return 2.3148148148148148e-7 * ( + 2.383072892806571e7 / np.power(-1.0, 1.0 * n) + + 970000.0 / (2.0 + n) + - 922800.0 / np.power(3.0 + n, 3) + - 524120.0 / np.power(3.0 + n, 2) + - 210625.0 / (3.0 + n) + - 1.56e6 / np.power(4.0 + n, 3) + + 1.1232e8 / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + + (9.36e7 * n) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + + (2.808e7 * np.power(n, 2)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + + (3.12e6 * np.power(n, 3)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + - 1.4e6 / np.power(4.0 + n, 2) + + 2.8e7 / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + + (1.68e7 * n) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + + (2.8e6 * np.power(n, 2)) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + - 172800.0 / np.power(5.0 + n, 3) + - 69120.0 / np.power(5.0 + n, 2) + - 442800.0 / np.power(6.0 + n, 3) + + 7.1131392e9 + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (9.6920064e9 * n) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (5.632416e9 * np.power(n, 2)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (1.7853696e9 * np.power(n, 3)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (3.241296e8 * np.power(n, 4)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (3.18816e7 * np.power(n, 5)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (1.3284e6 * np.power(n, 6)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - 204120.0 / np.power(6.0 + n, 2) + + 1.6003008e8 + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + + (1.5676416e8 * n) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + + (5.878656e7 * np.power(n, 2)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + + (9.79776e6 * np.power(n, 3)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + + (612360.0 * np.power(n, 4)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + + 428166.0 / (8.0 + 6.0 * n + np.power(n, 2)) + + (142722.0 * n) / (8.0 + 6.0 * n + np.power(n, 2)) + - 165888.0 / (15.0 + 8.0 * n + np.power(n, 2)) + - (41472.0 * n) / (15.0 + 8.0 * n + np.power(n, 2)) + + (1.4001361e7 * Sm1) / np.power(-1.0, 1.0 * n) + + (1.024412e7 * Sm2) / np.power(-1.0, 1.0 * n) + + (6.3228e6 * Sm3) / np.power(-1.0, 1.0 * n) + + ( + np.power(-1.0, 1.0 - 1.0 * n) + * (3.0568281e7 + 3.8246842e7 * n + 1.4001361e7 * np.power(n, 2)) + * np.power(-1.0, n) + ) + / np.power(1.0 + n, 3) + ) + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def F20(n, Sm1, Sm2, Sm3): + return 2.3148148148148148e-7 * ( + 1.8204889223408133e7 / np.power(-1.0, 1.0 * n) + - 650000.0 / (2.0 + n) + - 382800.0 / np.power(3.0 + n, 3) + - 254120.0 / np.power(3.0 + n, 2) + - 109375.0 / (3.0 + n) + + 600000.0 / np.power(4.0 + n, 3) + - 4.32e7 / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + - (3.6e7 * n) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + - (1.08e7 * np.power(n, 2)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + - (1.2e6 * np.power(n, 3)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + + 760000.0 / np.power(4.0 + n, 2) + - 1.52e7 / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + - (9.12e6 * n) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + - (1.52e6 * np.power(n, 2)) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + - 172800.0 / np.power(5.0 + n, 3) + - 69120.0 / np.power(5.0 + n, 2) + + 97200.0 / np.power(6.0 + n, 3) + - 1.5614208e9 + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (2.1275136e9 * n) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (1.236384e9 * np.power(n, 2)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (3.919104e8 * np.power(n, 3)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (7.11504e7 * np.power(n, 4)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (6.9984e6 * np.power(n, 5)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (291600.0 * np.power(n, 6)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + 65880.0 / np.power(6.0 + n, 2) + - 5.164992e7 + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + - (5.059584e7 * n) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + - (1.897344e7 * np.power(n, 2)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + - (3.16224e6 * np.power(n, 3)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + - (197640.0 * np.power(n, 4)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + - 179334.0 / (8.0 + 6.0 * n + np.power(n, 2)) + - (59778.0 * n) / (8.0 + 6.0 * n + np.power(n, 2)) + - 165888.0 / (15.0 + 8.0 * n + np.power(n, 2)) + - (41472.0 * n) / (15.0 + 8.0 * n + np.power(n, 2)) + + (1.2280111e7 * Sm1) / np.power(-1.0, 1.0 * n) + + (7.81412e6 * Sm2) / np.power(-1.0, 1.0 * n) + + (3.6228e6 * Sm3) / np.power(-1.0, 1.0 * n) + + ( + np.power(-1.0, 1.0 - 1.0 * n) + * (2.3717031e7 + 3.2374342e7 * n + 1.2280111e7 * np.power(n, 2)) + * np.power(-1.0, n) + ) + / np.power(1.0 + n, 3) + ) diff --git a/src/eko/matching_conditions/n3lo/s_functions.py b/src/eko/matching_conditions/n3lo/s_functions.py index 658dddd71..878da94e7 100644 --- a/src/eko/matching_conditions/n3lo/s_functions.py +++ b/src/eko/matching_conditions/n3lo/s_functions.py @@ -8,27 +8,50 @@ from eko.anomalous_dimensions import harmonics from . import g_functions as gf +from . import f_functions as f zeta2 = harmonics.zeta2 zeta3 = harmonics.zeta3 +zeta4 = harmonics.zeta4 +zeta5 = harmonics.zeta5 li4half = 0.517479 log2 = np.log(2) -@nb.njit("c16(c16,c16)", cache=True) -def harmonic_Sm1(N, Sp1): - return (-1) ** N / 2 * (Sp1 - harmonics.harmonic_S1((N - 1) / 2)) - log2 +@nb.njit("c16(c16)", cache=True) +def harmonic_Sm1(N): + return (-1) ** N / 2 * ( + harmonics.harmonic_S1(N / 2) - harmonics.harmonic_S1((N - 1) / 2) + ) - log2 -@nb.njit("c16(c16,c16)", cache=True) -def harmonic_Sm2(N, Sp2): - return (-1) ** N / 4 * (Sp2 - harmonics.harmonic_S2((N - 1) / 2)) - zeta2 / 2 +@nb.njit("c16(c16)", cache=True) +def harmonic_Sm2(N): + return (-1) ** N / 4 * ( + harmonics.harmonic_S2(N / 2) - harmonics.harmonic_S2((N - 1) / 2) + ) - zeta2 / 2 -@nb.njit("c16(c16,c16)", cache=True) -def harmonic_Sm3(N, Sp3): - return (-1) ** N / 8 * (Sp3 - harmonics.harmonic_S3((N - 1) / 2)) - 3 / 4 * zeta3 +@nb.njit("c16(c16)", cache=True) +def harmonic_Sm3(N): + return (-1) ** N / 8 * ( + harmonics.harmonic_S3(N / 2) - harmonics.harmonic_S3((N - 1) / 2) + ) - 3 / 4 * zeta3 + + +@nb.njit("c16(c16)", cache=True) +def harmonic_Sm4(N): + return (-1) ** N / 16 * ( + harmonics.harmonic_S4(N / 2) - harmonics.harmonic_S4((N - 1) / 2) + ) - 7 / 8 * zeta4 + + +@nb.njit("c16(c16)", cache=True) +def harmonic_Sm5(N): + return (-1) ** N / 32 * ( + harmonics.harmonic_S5(N / 2) - harmonics.harmonic_S5((N - 1) / 2) + ) - 15 / 16 * zeta5 @nb.njit("c16(c16,c16,c16)", cache=True) @@ -58,14 +81,142 @@ def harmonic_S2m1(N, S2, Sm1, Sm2): ) -# def harmonic_Sm31(N,Sm1,Sm2): -# return ( -# (-1) ** N * gf.mellin_g6(N) -# + zeta2 * Sm2 -# - zeta3 * Sm1 -# - 3 / 5 * zeta2 ** 2 -# + 2 * li4half -# + 3 / 4 * zeta3 * log2 -# - 1 / 2 * zeta2 * log2 ** 2 -# + 1 / 12 * log2 ** 4 -# ) +@nb.njit("c16(c16,c16,c16)", cache=True) +def harmonic_Sm31(N, Sm1, Sm2): + return ( + (-1) ** N * gf.mellin_g6(N) + + zeta2 * Sm2 + - zeta3 * Sm1 + - 3 / 5 * zeta2 ** 2 + + 2 * li4half + + 3 / 4 * zeta3 * log2 + - 1 / 2 * zeta2 * log2 ** 2 + + 1 / 12 * log2 ** 4 + ) + + +@nb.njit("c16(c16,c16)", cache=True) +def harmonic_Sm22(N, Sm31): + return ( + (-1) ** N * gf.mellin_g5(N) + - 2 * Sm31 + + 2 * zeta2 * harmonic_Sm2(N) + + 3 / 40 * zeta2 ** 2 + ) + + +@nb.njit("c16(c16,c16)", cache=True) +def harmonic_Sm211(N, Sm1): + return ( + -((-1) ** N) * gf.mellin_g8(N) + + zeta3 * Sm1 + - li4half + + 1 / 8 * zeta2 ** 2 + + 1 / 8 * zeta3 * log2 + + 1 / 4 * zeta2 * log2 ** 2 + - 1 / 24 * log2 ** 4 + ) + + +@nb.njit("c16(c16,c16)", cache=True) +def harmonic_Sm2m1(N, S1, S2, Sm2): + return -gf.mellin_g19(N, S1) + log2 * (S2 - Sm2) - 5 / 8 * zeta3 + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def harmonic_S211(N, S1, S2, S3): + return -gf.mellin_g21(N, S1, S2, S3) + 6 / 5 * zeta2 ** 2 + + +@nb.njit("c16(c16,c16,c16)", cache=True) +def harmonic_S31(N, S2, S4): + return ( + 1 / 2 * gf.mellin_g22(N) + - 1 / 4 * S4 + - 1 / 4 * S2 ** 2 + + zeta2 * S2 + - 3 / 20 * zeta2 ** 2 + ) + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def harmonic_S41(N, S1, S2, S3): + return -f.F9(N, S1) + S1 * zeta4 - S2 * zeta3 + S3 * zeta2 + + +@nb.njit("c16(c16,c16,c16)", cache=True) +def harmonic_S311(N, S1, S2): + return f.F11(N, S1, S2) + zeta3 * S2 - zeta4 / 4 * S1 + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def harmonic_S221(N, S1, S2, S21): + return ( + -2 * f.F11(N, S1, S2) + + 1 / 2 * f.F13(N, S1, S2) + + zeta2 * S21 + - 3 / 10 * zeta2 ** 2 * S1 + ) + + +@nb.njit("c16(c16,c16,c16,c16,c16,c16)", cache=True) +def harmonic_Sm221(N, S1, S2, Sm1, S21, Sm21): + return ( + (-1) ** (N + 1) * (2 * f.F12(N, S1, S2) - 1 / 2 * f.F14(N, S1, S2, S21)) + + zeta2 * Sm21 + - 3 / 10 * zeta2 ** 2 * Sm1 + - 0.119102 + + 0.0251709 + ) + + +@nb.njit("c16(c16,c16,c16,c16,c16,c16,c16)", cache=True) +def harmonic_S21m2(N, S1, S2, Sm1, Sm2, Sm3, S21, Sm21, S2m1): + return ( + (-1) ** (N) * f.F16(N, S1, Sm1, Sm2, Sm3, Sm21) + - 1 / 2 * zeta2 * (S21 - S2m1) + - (1 / 8 * zeta3 - 1 / 2 * zeta2 * log2) * (S2 - Sm2) + + 1 / 8 * zeta2 ** 2 * Sm1 + + 0.0854806 + ) + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def harmonic_S2111(N, S1, S2, S3): + return -f.F17(N, S1, S2, S3) + zeta4 * S1 + + +@nb.njit("c16(c16,c16,c16,c16,c16)", cache=True) +def harmonic_Sm2111(N, S1, S2, S3, Sm1): + return ( + (-1) ** (N + 1) * f.F18(N, S1, S2, S3) + + zeta4 * Sm1 + - 0.706186 + + 0.693147 * zeta4 + ) + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def harmonic_S23(N, S1, S2, S3): + return f.F19(N, S1, S2, S3) + 3 * zeta4 * S1 + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def harmonic_Sm23(N, Sm1, Sm2, Sm3): + return ( + (-1) ** N * f.F20(N, Sm1, Sm2, Sm3) + + 3 * zeta4 * Sm1 + + 21 / 32 * zeta5 + + 3 * zeta4 * log2 + - 3 / 4 * zeta2 * zeta3 + ) + + +@nb.njit("c16(c16,c16,c16,c16,c16)", cache=True) +def harmonic_S2m3(N, S2, Sm1, Sm2, Sm3): + return ( + (-1) ** (N + 1) * f.F21(N, Sm1, Sm2, Sm3) + + 3 / 4 * zeta3 * (Sm2 - S2) + - 21 / 8 * zeta4 * Sm1 + - 1.32056 + ) diff --git a/tests/test_ad_harmonics.py b/tests/test_ad_harmonics.py index 9dc86b78b..2ec136b41 100644 --- a/tests/test_ad_harmonics.py +++ b/tests/test_ad_harmonics.py @@ -86,8 +86,8 @@ def test_harmonic_Sx(): def sx(n, m): return np.sum([1 / k ** m for k in range(1, n + 1)]) - ls = [harmonics.harmonic_S1, harmonics.harmonic_S2, harmonics.harmonic_S3] - for k in range(1, 3 + 1): + ls = [harmonics.harmonic_S1, harmonics.harmonic_S2, harmonics.harmonic_S3, harmonics.harmonic_S4, harmonics.harmonic_S5] + for k in range(1, 5 + 1): for n in range(1, 4 + 1): np.testing.assert_almost_equal(ls[k - 1](n), sx(n, k)) diff --git a/tests/test_f_functions.py b/tests/test_f_functions.py index c5269d4b0..8d051c22f 100644 --- a/tests/test_f_functions.py +++ b/tests/test_f_functions.py @@ -1,16 +1,15 @@ # -*- coding: utf-8 -*- -# Test G functions impleeted by muselli PhD +# Test F functions implementing w5 harmonics sums import numpy as np from eko.anomalous_dimensions import harmonics -import eko.matching_conditions.n3lo.f_functions as f import eko.matching_conditions.n3lo.s_functions as sf zeta2 = harmonics.zeta2 zeta3 = harmonics.zeta3 zeta4 = harmonics.zeta4 - +zeta5 = harmonics.zeta5 log2 = np.log(2) # reference values coming fom mathematica @@ -41,18 +40,28 @@ -0.706186 - 2.32698e-9j, -0.704801, ], - 'Sm21': [-1., -0.625, -0.751192 - 0.000147181j, -0.751286 - 1.17067e-9j, -0.751029] + "Sm21": [ + -1.0, + -0.625, + -0.751192 - 0.000147181j, + -0.751286 - 1.17067e-9j, + -0.751029, + ], + "S23": [1.0, 1.28125, 1.45296 + 0.227775j, 1.65521 + 0.0442804j, 1.73653], + "S2m3": [-1.0, -1.21875, -1.35491 - 0.173841j, -1.50575 - 0.0332824j, -1.56676], + "Sm23": [-1.0, -0.71875, -0.802462 - 0.000100325j, -0.802494, -0.802435], } # copare the exact values of some harmonics # All the harmonics defition are coming from :cite`:Bl_mlein_2009` section 9. +# F19, F20,F21 are not present in that paper. def test_F9(): for N, vals in zip(testN, refvals["S41"]): S1 = harmonics.harmonic_S1(N) S2 = harmonics.harmonic_S2(N) S3 = harmonics.harmonic_S3(N) - S41 = -f.F9(N, S1) + S1 * zeta4 - S2 * zeta3 + S3 * zeta2 + S41 = sf.harmonic_S41(N, S1, S2, S3) np.testing.assert_allclose(S41, vals, atol=1e-05) @@ -60,7 +69,7 @@ def test_F11(): for N, vals in zip(testN, refvals["S311"]): S1 = harmonics.harmonic_S1(N) S2 = harmonics.harmonic_S2(N) - S311 = f.F11(N, S1, S2) + zeta3 * S2 - zeta4 / 4 * S1 + S311 = sf.harmonic_S311(N, S1, S2) np.testing.assert_allclose(S311, vals, atol=1e-05) @@ -69,12 +78,7 @@ def test_F13(): S1 = harmonics.harmonic_S1(N) S2 = harmonics.harmonic_S2(N) S21 = sf.harmonic_S21(N, S1, S2) - S221 = ( - -2 * f.F11(N, S1, S2) - + 1 / 2 * f.F13(N, S1, S2) - + zeta2 * S21 - - 3 / 10 * zeta2 ** 2 * S1 - ) + S221 = sf.harmonic_S221(N, S1, S2, S21) np.testing.assert_allclose(S221, vals, atol=1e-05) @@ -83,42 +87,33 @@ def test_F12_F14(): for N, vals in zip(testN, refvals["Sm221"]): S1 = harmonics.harmonic_S1(N) S2 = harmonics.harmonic_S2(N) - Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N / 2)) + Sm1 = sf.harmonic_Sm1(N) S21 = sf.harmonic_S21(N, S1, S2) Sm21 = sf.harmonic_Sm21(N, Sm1) - Sm221 = ( - (-1) ** (N + 1) * (2 * f.F12(N, S1, S2) - 1 / 2 * f.F14(N, S1, S2, S21)) - + zeta2 * Sm21 - - 3 / 10 * zeta2 ** 2 * Sm1 - - 0.119102 + 0.0251709 - ) + Sm221 = sf.harmonic_Sm221(N, S1, S2, Sm1, S21, Sm21) np.testing.assert_allclose(Sm221, vals, atol=1e-05) + def test_F16(): for N, vals in zip(testN, refvals["S21m2"]): S1 = harmonics.harmonic_S1(N) S2 = harmonics.harmonic_S2(N) - Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N / 2)) - Sm2 = sf.harmonic_Sm2(N, harmonics.harmonic_S2(N / 2)) - Sm3 = sf.harmonic_Sm3(N, harmonics.harmonic_S3(N / 2)) + Sm1 = sf.harmonic_Sm1(N) + Sm2 = sf.harmonic_Sm2(N) + Sm3 = sf.harmonic_Sm3(N) S21 = sf.harmonic_S21(N, S1, S2) S2m1 = sf.harmonic_S2m1(N, S2, Sm1, Sm2) Sm21 = sf.harmonic_Sm21(N, Sm1) - S21m2 = ( - (-1) ** (N) * f.F16(N, S1, Sm1, Sm2, Sm3, Sm21) - - 1 / 2 * zeta2 * (S21 - S2m1) - - (1 / 8 * zeta3 - 1 / 2 * zeta2 * log2) * (S2 - Sm2) - + 1 / 8 * zeta2 ** 2 * Sm1 - + 0.0854806 - ) + S21m2 = sf.harmonic_S21m2(N, S1, S2, Sm1, Sm2, Sm3, S21, Sm21, S2m1) np.testing.assert_allclose(S21m2, vals, atol=1e-04) + def test_F17(): for N, vals in zip(testN, refvals["S2111"]): S1 = harmonics.harmonic_S1(N) S2 = harmonics.harmonic_S2(N) S3 = harmonics.harmonic_S3(N) - S2111 = -f.F17(N, S1, S2, S3) + zeta4 * S1 + S2111 = sf.harmonic_S2111(N, S1, S2, S3) np.testing.assert_allclose(S2111, vals, atol=1e-05) @@ -127,16 +122,37 @@ def test_F18(): S1 = harmonics.harmonic_S1(N) S2 = harmonics.harmonic_S2(N) S3 = harmonics.harmonic_S3(N) - Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N / 2)) - Sm2111 = ( - (-1) ** (N + 1) * f.F18(N, S1, S2, S3) - + zeta4 * Sm1 - - 0.706186 - + 0.693147 * zeta4 - ) + Sm1 = sf.harmonic_Sm1(N) + Sm2111 = sf.harmonic_Sm2111(N, S1, S2, S3, Sm1) np.testing.assert_allclose(Sm2111, vals, atol=1e-05) -def test_Sm21(): - for N, vals in zip(testN, refvals["Sm21"]): - Sm1 = sf.harmonic_Sm1(N,harmonics.harmonic_S1(N / 2)) - np.testing.assert_allclose(sf.harmonic_Sm21(N, Sm1), vals, atol=1e-05) + +# different parametrization, less accurate +def test_F19(): + for N, vals in zip(testN, refvals["S23"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + S3 = harmonics.harmonic_S3(N) + S23 = sf.harmonic_S23(N, S1, S2, S3) + np.testing.assert_allclose(S23, vals, rtol=2e-03) + + +# different parametrization, less accurate +def test_F20(): + for N, vals in zip(testN, refvals["Sm23"]): + Sm3 = sf.harmonic_Sm3(N) + Sm2 = sf.harmonic_Sm2(N) + Sm1 = sf.harmonic_Sm1(N) + Sm23 = sf.harmonic_Sm23(N, Sm1, Sm2, Sm3) + np.testing.assert_allclose(Sm23, vals, rtol=1e-03) + + +# different parametrization, less accurate +def test_F21(): + for N, vals in zip(testN, refvals["S2m3"]): + Sm3 = sf.harmonic_Sm3(N) + Sm2 = sf.harmonic_Sm2(N) + Sm1 = sf.harmonic_Sm1(N) + S2 = harmonics.harmonic_S2(N) + S2m3 = sf.harmonic_S2m3(N, S2, Sm1, Sm2, Sm3) + np.testing.assert_allclose(S2m3, vals, rtol=1e-03) diff --git a/tests/test_g_functions.py b/tests/test_g_functions.py index 19d2a7da5..41014d646 100644 --- a/tests/test_g_functions.py +++ b/tests/test_g_functions.py @@ -7,39 +7,20 @@ import eko.matching_conditions.n3lo.g_functions as gf import eko.matching_conditions.n3lo.s_functions as sf -zeta2 = harmonics.zeta2 zeta3 = harmonics.zeta3 - -li4half = 0.517479 -li5half = 0.508401 log2 = np.log(2) testN = [1, 10, 100] -def harmonic_Sm31(N): - Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N/2)) - Sm2 = sf.harmonic_Sm2(N, harmonics.harmonic_S2(N/2)) - return ( - (-1) ** N * gf.mellin_g6(N) - + zeta2 * Sm2 - - zeta3 * Sm1 - - 3 / 5 * zeta2 ** 2 - + 2 * li4half - + 3 / 4 * zeta3 * log2 - - 1 / 2 * zeta2 * log2 ** 2 - + 1 / 12 * log2 ** 4 - ) - - # copare the exact values of some harmonics with Muselli parametrisations def test_g4(): refvals = [-1, -1.34359, -1.40286] for N, vals in zip(testN, refvals): S2 = harmonics.harmonic_S2(N) - Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N/2)) - Sm2 = sf.harmonic_Sm2(N, harmonics.harmonic_S2(N/2)) + Sm1 = sf.harmonic_Sm1(N) + Sm2 = sf.harmonic_Sm2(N) S2m1 = sf.harmonic_S2m1(N, S2, Sm1, Sm2) np.testing.assert_allclose(S2m1, vals, atol=1e-05) @@ -47,37 +28,27 @@ def test_g4(): def test_g6(): refvals = [-1, -0.857976, -0.859245] for N, vals in zip(testN, refvals): - - Sm31 = harmonic_Sm31(N) + Sm1 = sf.harmonic_Sm1(N) + Sm2 = sf.harmonic_Sm2(N) + Sm31 = sf.harmonic_Sm31(N, Sm1, Sm2) np.testing.assert_allclose(Sm31, vals, atol=1e-05) def test_g5(): refvals = [-1, -0.777375, -0.784297] for N, vals in zip(testN, refvals): - Sm31 = harmonic_Sm31(N) - Sm22 = ( - (-1) ** N * gf.mellin_g5(N) - - 2 * Sm31 - + 2 * zeta2 * sf.harmonic_Sm2(N, harmonics.harmonic_S2(N/2)) - + 3 / 40 * zeta2 ** 2 - ) + Sm1 = sf.harmonic_Sm1(N) + Sm2 = sf.harmonic_Sm2(N) + Sm31 = sf.harmonic_Sm31(N, Sm1, Sm2) + Sm22 = sf.harmonic_Sm22(N, Sm31) np.testing.assert_allclose(Sm22, vals, atol=1e-05) def test_g8(): refvals = [-1, -0.696836, -0.719637] for N, vals in zip(testN, refvals): - Sm1 = sf.harmonic_Sm1(N, harmonics.harmonic_S1(N/2)) - Sm211 = ( - -((-1) ** N) * gf.mellin_g8(N) - + zeta3 * Sm1 - - li4half - + 1 / 8 * zeta2 ** 2 - + 1 / 8 * zeta3 * log2 - + 1 / 4 * zeta2 * log2 ** 2 - - 1 / 24 * log2 ** 4 - ) + Sm1 = sf.harmonic_Sm1(N) + Sm211 = sf.harmonic_Sm211(N, Sm1) np.testing.assert_allclose(Sm211, vals, atol=1e-05) @@ -95,11 +66,9 @@ def test_g19(): refvals = [1, 0.953673, 0.958928] for N, vals in zip(testN, refvals): S1 = harmonics.harmonic_S1(N) - Sm2m1 = ( - -gf.mellin_g19(N, S1) - + log2 * (harmonics.harmonic_S2(N) - sf.harmonic_Sm2(N, harmonics.harmonic_S2(N/2))) - - 5 / 8 * zeta3 - ) + S2 = harmonics.harmonic_S2(N) + Sm2 = sf.harmonic_Sm2(N) + Sm2m1 = sf.harmonic_Sm2m1(N, S1, S2, Sm2) np.testing.assert_allclose(Sm2m1, vals, atol=1e-05) @@ -110,7 +79,7 @@ def test_g21(): S1 = harmonics.harmonic_S1(N) S2 = harmonics.harmonic_S2(N) S3 = harmonics.harmonic_S3(N) - S211 = -gf.mellin_g21(N, S1, S2, S3) + 6 / 5 * zeta2 ** 2 + S211 = sf.harmonic_S211(N, S1, S2, S3) np.testing.assert_allclose(S211, vals, atol=1e-05) @@ -119,11 +88,6 @@ def test_g22(): refvals = [1, 1.1875, 1.2554, 1.33724, 1.35262] for N, vals in zip(testN, refvals): S2 = harmonics.harmonic_S2(N) - S31 = ( - 1 / 2 * gf.mellin_g22(N) - - 1 / 4 * harmonics.harmonic_S4(N) - - 1 / 4 * S2 ** 2 - + zeta2 * S2 - - 3 / 20 * zeta2 ** 2 - ) + S4 = harmonics.harmonic_S4(N) + S31 = sf.harmonic_S31(N, S2, S4) np.testing.assert_allclose(S31, vals, atol=1e-05) diff --git a/tests/test_matching_nnlo.py b/tests/test_matching_nnlo.py index 6463d1a3b..2f4ba2b8e 100644 --- a/tests/test_matching_nnlo.py +++ b/tests/test_matching_nnlo.py @@ -144,9 +144,9 @@ def test_Bluemlein_2(): def test_Hg2_pegasus(): - # Test againnt the parametrized expession for A_Hg_2 + # Test against the parametrized expression for A_Hg_2 # coming from Pegasus code - # This expession is less accurate. + # This parametrization is less accurate. L = 0 for N in range(3, 20): diff --git a/tests/test_s_functions.py b/tests/test_s_functions.py new file mode 100644 index 000000000..c01524d69 --- /dev/null +++ b/tests/test_s_functions.py @@ -0,0 +1,60 @@ +# -*- coding: utf-8 -*- +# Test G functions impleeted by muselli PhD + +import numpy as np + +import eko.matching_conditions.n3lo.s_functions as sf + +# reference values coming fom mathematica +testN = [1, 2, 2 + 2j, 10 + 5j, 100] +refvals = { + "Sm1": [-1.0, -0.5, -0.692917 - 0.000175788j, -0.693147 - 2.77406e-9j, -0.688172], + "Sm2": [ + -1.0, + -0.75, + -0.822442 - 0.0000853585j, + -0.822467 - 4.29516e-10j, + -0.822418, + ], + "Sm3": [ + -1.0, + -0.875, + -0.901551 - 0.0000255879j, + -0.901543 - 4.61382e-11j, + -0.901542, + ], + "Sm4": [ + -1.0, + -0.9375, + -0.947039 - 4.84597e-6j, + -0.947033 - 3.99567e-12j, + -0.947033, + ], + "Sm5": [-1.0, -0.96875, -0.972122 - 1.13162e-7j, -0.97212 - 2.81097e-13j, -0.97212], + "Sm21": [ + -1.0, + -0.625, + -0.751192 - 0.000147181j, + -0.751286 - 1.17067e-9j, + -0.751029, + ], +} + + +def test_Sm21(): + for N, vals in zip(testN, refvals["Sm21"]): + Sm1 = sf.harmonic_Sm1(N) + np.testing.assert_allclose(sf.harmonic_Sm21(N, Sm1), vals, atol=1e-06) + + +def test_Smx(): + for j, N in enumerate(testN): + smx = [ + sf.harmonic_Sm1(N), + sf.harmonic_Sm2(N), + sf.harmonic_Sm3(N), + sf.harmonic_Sm4(N), + sf.harmonic_Sm5(N), + ] + for i, sm in enumerate(smx): + np.testing.assert_allclose(sm, refvals[f"Sm{i+1}"][j], atol=1e-06) From 435392d1236c7ff6d908c5f68b4d6981fd50a2b4 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 28 Sep 2021 10:27:12 +0200 Subject: [PATCH 33/71] New parametrization for F14 F12 --- .../matching_conditions/n3lo/f_functions.py | 11208 +++++++--------- .../matching_conditions/n3lo/s_functions.py | 10 +- tests/test_f_functions.py | 2 +- tests/test_g_functions.py | 2 +- 4 files changed, 4735 insertions(+), 6487 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/f_functions.py b/src/eko/matching_conditions/n3lo/f_functions.py index 58361782d..4127f2b75 100644 --- a/src/eko/matching_conditions/n3lo/f_functions.py +++ b/src/eko/matching_conditions/n3lo/f_functions.py @@ -231,166 +231,216 @@ def F17(n, S1, S2, S3): ) -@nb.njit("c16(c16,c16,c16,c16)", cache=True) -def F14(n, S1, S2, S21): +@nb.njit("c16(c16,c16,c16)", cache=True) +def F11(n, S1, S2): return ( - 1.875523244753495 - + 0.49999902059348167 + -0.1570209743051114 * n + - (0.4961137242141078 * n) / (2.0 + n) + + (0.14325154607236013 * n) / (3.0 + n) + + (0.043572446555835365 * n) / (4.0 + n) + - (0.1367619721729137 * n) / (5.0 + n) + + (0.5737638752229648 * n) / (6.0 + n) + - (1.6610332243741988 * n) / (7.0 + n) + + (3.333896376517311 * n) / (8.0 + n) + - (4.660416088583179 * n) / (9.0 + n) + + (4.454651830395971 * n) / (10.0 + n) + - (2.7814009672516686 * n) / (11.0 + n) + + (1.0238605215663694 * n) / (12.0 + n) + - (0.16899247190231767 * n) / (13.0 + n) + - 0.4887437258762844 * (-1.0 + 1 / (1.0 + n)) + - 1.0 + * n * ( - 4.808227612638377 / (2.0 + n) - + (3.2898681336964524 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / (2.0 + n) + -0.1570209813585035 + + 0.4166666666666667 / np.power(n, 3) + + 0.47941919157221546 / np.power(n, 2) + - 1.0 / np.power(1.0 + n, 3) + - 1.75 / np.power(1.0 + n, 2) + + 0.009326544681477866 / (1.0 + n) + + 0.75 / np.power(2.0 + n, 3) + + 1.25 / np.power(2.0 + n, 2) + + 0.8057445842680144 / (2.0 + n) + - 0.16666666666666666 / np.power(3.0 + n, 3) + - 0.25 / np.power(3.0 + n, 2) + - 0.13958627001930435 / (3.0 + n) + - (0.25 * (4.0 + 7.0 * (1.0 + n)) * S1) / np.power(1.0 + n, 2) + + (0.75 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 2) + + (1.25 * (1 / (1.0 + n) + S1)) / (2.0 + n) + - (0.16666666666666666 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) + / np.power(3.0 + n, 2) + - (0.25 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / (3.0 + n) - ( - 4.0 + 0.002777777777777778 + * (22.59090896599757 - 172.59090896599758 * (1.0 + n)) + * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) + ) + / np.power(n, 2) + + ( + 0.75 * ( - 0.5 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 2) - + 0.5 * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) + np.power(1.0 + n, -2) + + S1 / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) ) ) - / np.power(2.0 + n, 2) + / (2.0 + n) - ( - 2.0 + 1.0 * ( - np.power(1.0 + n, -3) - + np.power(2.0 + n, -3) - + S1 / np.power(1.0 + n, 2) - + (1 / (1.0 + n) + S1) / np.power(2.0 + n, 2) - + S21 + np.power(1.0 + n, -2) + + S1 / (1.0 + n) + - (1.0 * (1 / (1.0 + n) + S1)) / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) ) ) - / (2.0 + n) - + n - * ( - 6.0 / np.power(2.0 + n, 5) - - 3.2898681336964524 / np.power(2.0 + n, 3) - - 4.808227612638377 / np.power(2.0 + n, 2) - + 2.705808084277845 / (2.0 + n) - + (6.0 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 4) - - (3.2898681336964524 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 2) - + ( - 4.0 - * ( - 0.5 * np.power(1 / (1.0 + n) + S1, 2) - + 0.5 * (np.power(1.0 + n, -2) + S2) - ) + / (1.0 + n) + - ( + 0.16666666666666666 + * ( + np.power(1.0 + n, -2) + + np.power(2.0 + n, -2) + + S1 / (1.0 + n) + + (1 / (1.0 + n) + S1) / (2.0 + n) + + 0.5 * (np.power(S1, 2) + S2) + ) + ) + / (3.0 + n) + + ( + 0.4166666666666667 + * ( + np.power(1.0 + n, -2) + + 1 / (n * (1.0 + n)) + + S1 / (1.0 + n) + + ((1.0 - 2.0 * (1.0 + n)) * (1 / (1.0 + n) + S1)) / (n * (1.0 + n)) + + 0.5 * (np.power(S1, 2) + S2) ) - / np.power(2.0 + n, 3) - + (2.0 * (np.power(1.0 + n, -3) + S1 / np.power(1.0 + n, 2) + S21)) - / np.power(2.0 + n, 2) ) + / n ) + ) + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def F18(n, S1, S2, S3): + return ( + 0.7502092979013981 - 0.9999999952263307 * ( - 4.808227612638377 / (1.0 + n) - + (3.2898681336964524 * (1 / (1.0 + n) + S1)) / (1.0 + n) - - ( - 4.0 - * ( - 0.5 * np.power(1 / (1.0 + n) + S1, 2) - + 0.5 * (np.power(1.0 + n, -2) + S2) + n + * ( + -1.0 / np.power(1.0 + n, 5) + + 1.0823232337111381 / (1.0 + n) + - (1.0 * S1) / np.power(1.0 + n, 4) + - (1.0 * (0.5 * np.power(S1, 2) + 0.5 * S2)) / np.power(1.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 * np.power(S1, 3) + + 0.5 * S1 * S2 + + 0.3333333333333333 * S3 + ) ) + / np.power(1.0 + n, 2) + ) + + ( + 0.16666666666666666 * np.power(1 / (1.0 + n) + S1, 3) + + 0.5 * (1 / (1.0 + n) + S1) * (np.power(1.0 + n, -2) + S2) + + 0.3333333333333333 * (np.power(1.0 + n, -3) + S3) ) - / np.power(1.0 + n, 2) - - (2.0 * (np.power(1.0 + n, -3) + S1 / np.power(1.0 + n, 2) + S21)) / (1.0 + n) + ) + + 0.49999902059348167 + * ( + ( + 0.16666666666666666 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 3) + + 0.5 + * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) + + 0.3333333333333333 + * (np.power(1.0 + n, -3) + np.power(2.0 + n, -3) + S3) + ) + / (2.0 + n) + n * ( - 6.0 / np.power(1.0 + n, 5) - - 3.2898681336964524 / np.power(1.0 + n, 3) - - 4.808227612638377 / np.power(1.0 + n, 2) - + 2.705808084277845 / (1.0 + n) - + (6.0 * S1) / np.power(1.0 + n, 4) - - (3.2898681336964524 * S1) / np.power(1.0 + n, 2) - + (4.0 * (0.5 * np.power(S1, 2) + 0.5 * S2)) / np.power(1.0 + n, 3) - + ( - 2.0 + -1.0 / np.power(2.0 + n, 5) + + 1.0823232337111381 / (2.0 + n) + - (1.0 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 4) + - ( + 1.0 * ( - np.power(1.0 + n, -3) - + S1 / np.power(1.0 + n, 2) - - (1.0 * (1 / (1.0 + n) + S1)) / np.power(1.0 + n, 2) - + S21 + 0.5 * np.power(1 / (1.0 + n) + S1, 2) + + 0.5 * (np.power(1.0 + n, -2) + S2) ) ) - / np.power(1.0 + n, 2) + / np.power(2.0 + n, 3) + - ( + 1.0 + * ( + 0.16666666666666666 * np.power(1 / (1.0 + n) + S1, 3) + + 0.5 * (1 / (1.0 + n) + S1) * (np.power(1.0 + n, -2) + S2) + + 0.3333333333333333 * (np.power(1.0 + n, -3) + S3) + ) + ) + / np.power(2.0 + n, 2) ) ) - 0.3332995604546604 * ( - 4.808227612638377 / (3.0 + n) - + ( - 3.2898681336964524 + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1, + 3, + ) + + 0.5 * ( 1 / (1.0 + n) + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + S1 ) - ) - / (3.0 + n) - - ( - 4.0 * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) - + S2 - ) + np.power(1.0 + n, -2) + + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S2 ) - ) - / np.power(3.0 + n, 2) - - ( - 2.0 + + 0.3333333333333333 * ( np.power(1.0 + n, -3) + ( - 11.0 - + 20.0 * (1.0 + n) - + 13.0 * np.power(1.0 + n, 2) - + 3.0 * np.power(1.0 + n, 3) + (3.0 + 2.0 * (1.0 + n)) + * (3.0 + 3.0 * (1.0 + n) + np.power(1.0 + n, 2)) ) / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) - + S1 / np.power(1.0 + n, 2) - + ( - (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) - * (1 / (1.0 + n) + S1) - ) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) - + S21 + + S3 ) ) / (3.0 + n) + n * ( - 6.0 / np.power(3.0 + n, 5) - - 3.2898681336964524 / np.power(3.0 + n, 3) - - 4.808227612638377 / np.power(3.0 + n, 2) - + 2.705808084277845 / (3.0 + n) - + (6.0 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / np.power(3.0 + n, 4) - - (3.2898681336964524 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) - / np.power(3.0 + n, 2) - + ( - 4.0 + -1.0 / np.power(3.0 + n, 5) + + 1.0823232337111381 / (3.0 + n) + - (1.0 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / np.power(3.0 + n, 4) + - ( + 1.0 * ( 0.5 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 2) + 0.5 * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) ) ) / np.power(3.0 + n, 3) - + ( - 2.0 + - ( + 1.0 * ( - np.power(1.0 + n, -3) - + np.power(2.0 + n, -3) - + S1 / np.power(1.0 + n, 2) - + (1 / (1.0 + n) + S1) / np.power(2.0 + n, 2) - + S21 + 0.16666666666666666 + * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 3) + + 0.5 + * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) + + 0.3333333333333333 + * (np.power(1.0 + n, -3) + np.power(2.0 + n, -3) + S3) ) ) / np.power(3.0 + n, 2) @@ -398,94 +448,65 @@ def F14(n, S1, S2, S21): ) + 0.24954082848379078 * ( - 4.808227612638377 / (4.0 + n) - + ( - 3.2898681336964524 + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1, + 3, + ) + + 0.5 * ( 1 / (1.0 + n) + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + S1 ) - ) - / (4.0 + n) - - ( - 4.0 * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1, - 2, + np.power(1.0 + n, -2) + + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 49.0 - + 96.0 * (1.0 + n) - + 72.0 * np.power(1.0 + n, 2) - + 24.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - ) - + S2 + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) ) + + S2 ) - ) - / np.power(4.0 + n, 2) - - ( - 2.0 + + 0.3333333333333333 * ( np.power(1.0 + n, -3) + ( - 341.0 - + 1017.0 * (1.0 + n) - + 1289.0 * np.power(1.0 + n, 2) - + 881.0 * np.power(1.0 + n, 3) - + 340.0 * np.power(1.0 + n, 4) - + 70.0 * np.power(1.0 + n, 5) - + 6.0 * np.power(1.0 + n, 6) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - ) - + S1 / np.power(1.0 + n, 2) - + ( - ( - 49.0 - + 96.0 * (1.0 + n) - + 72.0 * np.power(1.0 + n, 2) - + 24.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) - * (1 / (1.0 + n) + S1) + 251.0 + + 684.0 * (1.0 + n) + + 795.0 * np.power(1.0 + n, 2) + + 504.0 * np.power(1.0 + n, 3) + + 183.0 * np.power(1.0 + n, 4) + + 36.0 * np.power(1.0 + n, 5) + + 3.0 * np.power(1.0 + n, 6) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) ) - + S21 + + S3 ) ) / (4.0 + n) + n * ( - 6.0 / np.power(4.0 + n, 5) - - 3.2898681336964524 / np.power(4.0 + n, 3) - - 4.808227612638377 / np.power(4.0 + n, 2) - + 2.705808084277845 / (4.0 + n) - + ( - 6.0 + -1.0 / np.power(4.0 + n, 5) + + 1.0823232337111381 / (4.0 + n) + - ( + 1.0 * ( 1 / (1.0 + n) + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) @@ -494,16 +515,7 @@ def F14(n, S1, S2, S21): ) / np.power(4.0 + n, 4) - ( - 3.2898681336964524 - * ( - 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) - + S1 - ) - ) - / np.power(4.0 + n, 2) - + ( - 4.0 + 1.0 * ( 0.5 * np.power( @@ -522,24 +534,38 @@ def F14(n, S1, S2, S21): ) ) / np.power(4.0 + n, 3) - + ( - 2.0 + - ( + 1.0 * ( - np.power(1.0 + n, -3) - + ( - 11.0 - + 20.0 * (1.0 + n) - + 13.0 * np.power(1.0 + n, 2) - + 3.0 * np.power(1.0 + n, 3) + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1, + 3, ) - / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) - + S1 / np.power(1.0 + n, 2) - + ( - (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) - * (1 / (1.0 + n) + S1) + + 0.5 + * ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + (3.0 + 2.0 * (1.0 + n)) + * (3.0 + 3.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + S3 ) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) - + S21 ) ) / np.power(4.0 + n, 2) @@ -547,10 +573,9 @@ def F14(n, S1, S2, S21): ) - 0.1967571967137462 * ( - 4.808227612638377 / (5.0 + n) - + ( - 3.2898681336964524 - * ( + ( + 0.16666666666666666 + * np.power( 1 / (1.0 + n) + ( 2.0 @@ -558,74 +583,22 @@ def F14(n, S1, S2, S21): * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) ) / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1 + + S1, + 3, ) - ) - / (5.0 + n) - - ( - 4.0 + + 0.5 * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 2.0 - * ( - 410.0 - + 1030.0 * (1.0 + n) - + 1081.0 * np.power(1.0 + n, 2) - + 600.0 * np.power(1.0 + n, 3) - + 185.0 * np.power(1.0 + n, 4) - + 30.0 * np.power(1.0 + n, 5) - + 2.0 * np.power(1.0 + n, 6) - ) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - ) - + S2 + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 ) - ) - / np.power(5.0 + n, 2) - - ( - 2.0 * ( - np.power(1.0 + n, -3) - + ( - 23624.0 - + 90576.0 * (1.0 + n) - + 155374.0 * np.power(1.0 + n, 2) - + 155615.0 * np.power(1.0 + n, 3) - + 99831.0 * np.power(1.0 + n, 4) - + 42413.0 * np.power(1.0 + n, 5) - + 11911.0 * np.power(1.0 + n, 6) - + 2130.0 * np.power(1.0 + n, 7) - + 220.0 * np.power(1.0 + n, 8) - + 10.0 * np.power(1.0 + n, 9) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - ) - + S1 / np.power(1.0 + n, 2) + np.power(1.0 + n, -2) + ( 2.0 * ( @@ -637,7 +610,6 @@ def F14(n, S1, S2, S21): + 30.0 * np.power(1.0 + n, 5) + 2.0 * np.power(1.0 + n, 6) ) - * (1 / (1.0 + n) + S1) ) / ( np.power(2.0 + n, 2) @@ -645,18 +617,42 @@ def F14(n, S1, S2, S21): * np.power(4.0 + n, 2) * np.power(5.0 + n, 2) ) - + S21 + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 1628.0 + + 5050.0 * (1.0 + n) + + 6935.0 * np.power(1.0 + n, 2) + + 5495.0 * np.power(1.0 + n, 3) + + 2737.0 * np.power(1.0 + n, 4) + + 875.0 * np.power(1.0 + n, 5) + + 175.0 * np.power(1.0 + n, 6) + + 20.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + S3 ) ) / (5.0 + n) + n * ( - 6.0 / np.power(5.0 + n, 5) - - 3.2898681336964524 / np.power(5.0 + n, 3) - - 4.808227612638377 / np.power(5.0 + n, 2) - + 2.705808084277845 / (5.0 + n) - + ( - 6.0 + -1.0 / np.power(5.0 + n, 5) + + 1.0823232337111381 / (5.0 + n) + - ( + 1.0 * ( 1 / (1.0 + n) + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) @@ -666,17 +662,7 @@ def F14(n, S1, S2, S21): ) / np.power(5.0 + n, 4) - ( - 3.2898681336964524 - * ( - 1 / (1.0 + n) - + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1 - ) - ) - / np.power(5.0 + n, 2) - + ( - 4.0 + 1.0 * ( 0.5 * np.power( @@ -706,41 +692,59 @@ def F14(n, S1, S2, S21): ) ) / np.power(5.0 + n, 3) - + ( - 2.0 + - ( + 1.0 * ( - np.power(1.0 + n, -3) - + ( - 341.0 - + 1017.0 * (1.0 + n) - + 1289.0 * np.power(1.0 + n, 2) - + 881.0 * np.power(1.0 + n, 3) - + 340.0 * np.power(1.0 + n, 4) - + 70.0 * np.power(1.0 + n, 5) - + 6.0 * np.power(1.0 + n, 6) + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1, + 3, ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) + + 0.5 + * ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 ) - + S1 / np.power(1.0 + n, 2) - + ( - ( + * ( + np.power(1.0 + n, -2) + + ( 49.0 + 96.0 * (1.0 + n) + 72.0 * np.power(1.0 + n, 2) + 24.0 * np.power(1.0 + n, 3) + 3.0 * np.power(1.0 + n, 4) ) - * (1 / (1.0 + n) + S1) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + S2 ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 251.0 + + 684.0 * (1.0 + n) + + 795.0 * np.power(1.0 + n, 2) + + 504.0 * np.power(1.0 + n, 3) + + 183.0 * np.power(1.0 + n, 4) + + 36.0 * np.power(1.0 + n, 5) + + 3.0 * np.power(1.0 + n, 6) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + + S3 ) - + S21 ) ) / np.power(5.0 + n, 2) @@ -748,12 +752,25 @@ def F14(n, S1, S2, S21): ) + 0.1530503487172192 * ( - 4.808227612638377 / (6.0 + n) - + ( - 3.2898681336964524 - * ( - 1 / (1.0 + n) - + ( + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( 274.0 + 450.0 * (1.0 + n) + 255.0 * np.power(1.0 + n, 2) @@ -763,69 +780,45 @@ def F14(n, S1, S2, S21): / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + S1 ) - ) - / (6.0 + n) - - ( - 4.0 * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) - + S1, - 2, + np.power(1.0 + n, -2) + + ( + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 21076.0 - + 62100.0 * (1.0 + n) - + 79650.0 * np.power(1.0 + n, 2) - + 57660.0 * np.power(1.0 + n, 3) - + 25685.0 * np.power(1.0 + n, 4) - + 7200.0 * np.power(1.0 + n, 5) - + 1240.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 5.0 * np.power(1.0 + n, 8) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - ) - + S2 + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) ) + + S2 ) - ) - / np.power(6.0 + n, 2) - - ( - 2.0 + + 0.3333333333333333 * ( np.power(1.0 + n, -3) + ( - 3.110824e6 - + 1.40106e7 * (1.0 + n) - + 2.894151e7 * np.power(1.0 + n, 2) - + 3.6105269e7 * np.power(1.0 + n, 3) - + 3.0197768e7 * np.power(1.0 + n, 4) - + 1.7798299e7 * np.power(1.0 + n, 5) - + 7.568825e6 * np.power(1.0 + n, 6) - + 2.337861e6 * np.power(1.0 + n, 7) - + 520317.0 * np.power(1.0 + n, 8) - + 81361.0 * np.power(1.0 + n, 9) - + 8485.0 * np.power(1.0 + n, 10) - + 530.0 * np.power(1.0 + n, 11) - + 15.0 * np.power(1.0 + n, 12) + 2.048824e6 + + 8.4339e6 * (1.0 + n) + + 1.595433e7 * np.power(1.0 + n, 2) + + 1.831824e7 * np.power(1.0 + n, 3) + + 1.419519e7 * np.power(1.0 + n, 4) + + 7.80975e6 * np.power(1.0 + n, 5) + + 3.124155e6 * np.power(1.0 + n, 6) + + 914760.0 * np.power(1.0 + n, 7) + + 194445.0 * np.power(1.0 + n, 8) + + 29250.0 * np.power(1.0 + n, 9) + + 2955.0 * np.power(1.0 + n, 10) + + 180.0 * np.power(1.0 + n, 11) + + 5.0 * np.power(1.0 + n, 12) ) / ( np.power(2.0 + n, 3) @@ -834,40 +827,16 @@ def F14(n, S1, S2, S21): * np.power(5.0 + n, 3) * np.power(6.0 + n, 3) ) - + S1 / np.power(1.0 + n, 2) - + ( - ( - 21076.0 - + 62100.0 * (1.0 + n) - + 79650.0 * np.power(1.0 + n, 2) - + 57660.0 * np.power(1.0 + n, 3) - + 25685.0 * np.power(1.0 + n, 4) - + 7200.0 * np.power(1.0 + n, 5) - + 1240.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 5.0 * np.power(1.0 + n, 8) - ) - * (1 / (1.0 + n) + S1) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - ) - + S21 + + S3 ) ) / (6.0 + n) + n * ( - 6.0 / np.power(6.0 + n, 5) - - 3.2898681336964524 / np.power(6.0 + n, 3) - - 4.808227612638377 / np.power(6.0 + n, 2) - + 2.705808084277845 / (6.0 + n) - + ( - 6.0 + -1.0 / np.power(6.0 + n, 5) + + 1.0823232337111381 / (6.0 + n) + - ( + 1.0 * ( 1 / (1.0 + n) + ( @@ -881,21 +850,7 @@ def F14(n, S1, S2, S21): ) / np.power(6.0 + n, 4) - ( - 3.2898681336964524 - * ( - 1 / (1.0 + n) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1 - ) - ) - / np.power(6.0 + n, 2) - + ( - 4.0 + 1.0 * ( 0.5 * np.power( @@ -935,49 +890,80 @@ def F14(n, S1, S2, S21): ) ) / np.power(6.0 + n, 3) - + ( - 2.0 + - ( + 1.0 * ( - np.power(1.0 + n, -3) - + ( - 23624.0 - + 90576.0 * (1.0 + n) - + 155374.0 * np.power(1.0 + n, 2) - + 155615.0 * np.power(1.0 + n, 3) - + 99831.0 * np.power(1.0 + n, 4) - + 42413.0 * np.power(1.0 + n, 5) - + 11911.0 * np.power(1.0 + n, 6) - + 2130.0 * np.power(1.0 + n, 7) - + 220.0 * np.power(1.0 + n, 8) - + 10.0 * np.power(1.0 + n, 9) + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1, + 3, ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 ) - + S1 / np.power(1.0 + n, 2) - + ( - 2.0 - * ( - 410.0 - + 1030.0 * (1.0 + n) - + 1081.0 * np.power(1.0 + n, 2) - + 600.0 * np.power(1.0 + n, 3) - + 185.0 * np.power(1.0 + n, 4) - + 30.0 * np.power(1.0 + n, 5) - + 2.0 * np.power(1.0 + n, 6) + * ( + np.power(1.0 + n, -2) + + ( + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) + ) ) - * (1 / (1.0 + n) + S1) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + S2 ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 1628.0 + + 5050.0 * (1.0 + n) + + 6935.0 * np.power(1.0 + n, 2) + + 5495.0 * np.power(1.0 + n, 3) + + 2737.0 * np.power(1.0 + n, 4) + + 875.0 * np.power(1.0 + n, 5) + + 175.0 * np.power(1.0 + n, 6) + + 20.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + S3 ) - + S21 ) ) / np.power(6.0 + n, 2) @@ -985,10 +971,9 @@ def F14(n, S1, S2, S21): ) - 0.10602798528818422 * ( - 4.808227612638377 / (7.0 + n) - + ( - 3.2898681336964524 - * ( + ( + 0.16666666666666666 + * np.power( 1 / (1.0 + n) + ( (7.0 + 2.0 * (1.0 + n)) @@ -1008,87 +993,79 @@ def F14(n, S1, S2, S21): * (6.0 + n) * (7.0 + n) ) - + S1 + + S1, + 3, ) - ) - / (7.0 + n) - - ( - 4.0 + + 0.5 * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - (7.0 + 2.0 * (1.0 + n)) - * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) ) - + S1, - 2, ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 773136.0 - + 2.554272e6 * (1.0 + n) - + 3.762752e6 * np.power(1.0 + n, 2) - + 3.23736e6 * np.power(1.0 + n, 3) - + 1.797035e6 * np.power(1.0 + n, 4) - + 671790.0 * np.power(1.0 + n, 5) - + 171248.0 * np.power(1.0 + n, 6) - + 29400.0 * np.power(1.0 + n, 7) - + 3255.0 * np.power(1.0 + n, 8) - + 210.0 * np.power(1.0 + n, 9) - + 6.0 * np.power(1.0 + n, 10) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - ) - + S2 + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) ) + + S1 ) - ) - / np.power(7.0 + n, 2) - - ( - 2.0 + * ( + np.power(1.0 + n, -2) + + ( + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 * ( np.power(1.0 + n, -3) + ( - 6.97339584e8 - + 3.525030432e9 * (1.0 + n) - + 8.293536336e9 * np.power(1.0 + n, 2) - + 1.2007529256e10 * np.power(1.0 + n, 3) - + 1.193375892e10 * np.power(1.0 + n, 4) - + 8.60864186e9 * np.power(1.0 + n, 5) - + 4.650892802e9 * np.power(1.0 + n, 6) - + 1.914862936e9 * np.power(1.0 + n, 7) - + 6.05522329e8 * np.power(1.0 + n, 8) - + 1.47044895e8 * np.power(1.0 + n, 9) - + 2.7198669e7 * np.power(1.0 + n, 10) - + 3.763711e6 * np.power(1.0 + n, 11) - + 377251.0 * np.power(1.0 + n, 12) - + 25865.0 * np.power(1.0 + n, 13) - + 1085.0 * np.power(1.0 + n, 14) - + 21.0 * np.power(1.0 + n, 15) + (7.0 + 2.0 * (1.0 + n)) + * ( + 6.3467712e7 + + 2.75413824e8 * (1.0 + n) + + 5.54256432e8 * np.power(1.0 + n, 2) + + 6.84826352e8 * np.power(1.0 + n, 3) + + 5.79544028e8 * np.power(1.0 + n, 4) + + 3.54873092e8 * np.power(1.0 + n, 5) + + 1.61970683e8 * np.power(1.0 + n, 6) + + 5.5932611e7 * np.power(1.0 + n, 7) + + 1.4676674e7 * np.power(1.0 + n, 8) + + 2.911041e6 * np.power(1.0 + n, 9) + + 429534.0 * np.power(1.0 + n, 10) + + 45717.0 * np.power(1.0 + n, 11) + + 3318.0 * np.power(1.0 + n, 12) + + 147.0 * np.power(1.0 + n, 13) + + 3.0 * np.power(1.0 + n, 14) + ) ) / ( np.power(2.0 + n, 3) @@ -1098,43 +1075,16 @@ def F14(n, S1, S2, S21): * np.power(6.0 + n, 3) * np.power(7.0 + n, 3) ) - + S1 / np.power(1.0 + n, 2) - + ( - ( - 773136.0 - + 2.554272e6 * (1.0 + n) - + 3.762752e6 * np.power(1.0 + n, 2) - + 3.23736e6 * np.power(1.0 + n, 3) - + 1.797035e6 * np.power(1.0 + n, 4) - + 671790.0 * np.power(1.0 + n, 5) - + 171248.0 * np.power(1.0 + n, 6) - + 29400.0 * np.power(1.0 + n, 7) - + 3255.0 * np.power(1.0 + n, 8) - + 210.0 * np.power(1.0 + n, 9) - + 6.0 * np.power(1.0 + n, 10) - ) - * (1 / (1.0 + n) + S1) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - ) - + S21 + + S3 ) ) / (7.0 + n) + n * ( - 6.0 / np.power(7.0 + n, 5) - - 3.2898681336964524 / np.power(7.0 + n, 3) - - 4.808227612638377 / np.power(7.0 + n, 2) - + 2.705808084277845 / (7.0 + n) - + ( - 6.0 + -1.0 / np.power(7.0 + n, 5) + + 1.0823232337111381 / (7.0 + n) + - ( + 1.0 * ( 1 / (1.0 + n) + ( @@ -1150,23 +1100,7 @@ def F14(n, S1, S2, S21): ) / np.power(7.0 + n, 4) - ( - 3.2898681336964524 - * ( - 1 / (1.0 + n) - + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) - + S1 - ) - ) - / np.power(7.0 + n, 2) - + ( - 4.0 + 1.0 * ( 0.5 * np.power( @@ -1214,35 +1148,51 @@ def F14(n, S1, S2, S21): ) ) / np.power(7.0 + n, 3) - + ( - 2.0 + - ( + 1.0 * ( - np.power(1.0 + n, -3) - + ( - 3.110824e6 - + 1.40106e7 * (1.0 + n) - + 2.894151e7 * np.power(1.0 + n, 2) - + 3.6105269e7 * np.power(1.0 + n, 3) - + 3.0197768e7 * np.power(1.0 + n, 4) - + 1.7798299e7 * np.power(1.0 + n, 5) - + 7.568825e6 * np.power(1.0 + n, 6) - + 2.337861e6 * np.power(1.0 + n, 7) - + 520317.0 * np.power(1.0 + n, 8) - + 81361.0 * np.power(1.0 + n, 9) - + 8485.0 * np.power(1.0 + n, 10) - + 530.0 * np.power(1.0 + n, 11) - + 15.0 * np.power(1.0 + n, 12) + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + ) + + S1, + 3, ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + ) + + S1 ) - + S1 / np.power(1.0 + n, 2) - + ( - ( + * ( + np.power(1.0 + n, -2) + + ( 21076.0 + 62100.0 * (1.0 + n) + 79650.0 * np.power(1.0 + n, 2) @@ -1253,16 +1203,42 @@ def F14(n, S1, S2, S21): + 120.0 * np.power(1.0 + n, 7) + 5.0 * np.power(1.0 + n, 8) ) - * (1 / (1.0 + n) + S1) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + S2 ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 2.048824e6 + + 8.4339e6 * (1.0 + n) + + 1.595433e7 * np.power(1.0 + n, 2) + + 1.831824e7 * np.power(1.0 + n, 3) + + 1.419519e7 * np.power(1.0 + n, 4) + + 7.80975e6 * np.power(1.0 + n, 5) + + 3.124155e6 * np.power(1.0 + n, 6) + + 914760.0 * np.power(1.0 + n, 7) + + 194445.0 * np.power(1.0 + n, 8) + + 29250.0 * np.power(1.0 + n, 9) + + 2955.0 * np.power(1.0 + n, 10) + + 180.0 * np.power(1.0 + n, 11) + + 5.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + + S3 ) - + S21 ) ) / np.power(7.0 + n, 2) @@ -1270,9 +1246,32 @@ def F14(n, S1, S2, S21): ) + 0.056951717764149916 * ( - 4.808227612638377 / (8.0 + n) - + ( - 3.2898681336964524 + ( + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1, + 3, + ) + + 0.5 * ( 1 / (1.0 + n) + ( @@ -1295,94 +1294,57 @@ def F14(n, S1, S2, S21): ) + S1 ) - ) - / (8.0 + n) - - ( - 4.0 * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + S1, - 2, + np.power(1.0 + n, -2) + + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 3.8402064e7 - + 1.38523392e8 * (1.0 + n) - + 2.26358048e8 * np.power(1.0 + n, 2) - + 2.20651312e8 * np.power(1.0 + n, 3) - + 1.42622963e8 * np.power(1.0 + n, 4) - + 6.434848e7 * np.power(1.0 + n, 5) - + 2.07774e7 * np.power(1.0 + n, 6) - + 4.838848e6 * np.power(1.0 + n, 7) - + 807086.0 * np.power(1.0 + n, 8) - + 94080.0 * np.power(1.0 + n, 9) - + 7280.0 * np.power(1.0 + n, 10) - + 336.0 * np.power(1.0 + n, 11) - + 7.0 * np.power(1.0 + n, 12) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - ) - + S2 + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) ) + + S2 ) - ) - / np.power(8.0 + n, 2) - - ( - 2.0 + + 0.3333333333333333 * ( np.power(1.0 + n, -3) + ( - 2.0 - * ( - 1.22980964256e11 - + 6.79202212752e11 * (1.0 + n) - + 1.762986212232e12 * np.power(1.0 + n, 2) - + 2.849976037428e12 * np.power(1.0 + n, 3) - + 3.208712317944e12 * np.power(1.0 + n, 4) - + 2.66793900071e12 * np.power(1.0 + n, 5) - + 1.696140569839e12 * np.power(1.0 + n, 6) - + 8.42534361945e11 * np.power(1.0 + n, 7) - + 3.31394293594e11 * np.power(1.0 + n, 8) - + 1.03973066426e11 * np.power(1.0 + n, 9) - + 2.6083138284e10 * np.power(1.0 + n, 10) - + 5.220244242e9 * np.power(1.0 + n, 11) - + 8.27501148e8 * np.power(1.0 + n, 12) - + 1.02512358e8 * np.power(1.0 + n, 13) - + 9.709175e6 * np.power(1.0 + n, 14) - + 678601.0 * np.power(1.0 + n, 15) - + 32970.0 * np.power(1.0 + n, 16) - + 994.0 * np.power(1.0 + n, 17) - + 14.0 * np.power(1.0 + n, 18) - ) + 1.52759224512e11 + + 7.72859090304e11 * (1.0 + n) + + 1.840340570544e12 * np.power(1.0 + n, 2) + + 2.738393029568e12 * np.power(1.0 + n, 3) + + 2.850741832092e12 * np.power(1.0 + n, 4) + + 2.203027167432e12 * np.power(1.0 + n, 5) + + 1.308849323187e12 * np.power(1.0 + n, 6) + + 6.10929168192e11 * np.power(1.0 + n, 7) + + 2.2702816521e11 * np.power(1.0 + n, 8) + + 6.7650709672e10 * np.power(1.0 + n, 9) + + 1.6200316881e10 * np.power(1.0 + n, 10) + + 3.110018688e9 * np.power(1.0 + n, 11) + + 4.75055e8 * np.power(1.0 + n, 12) + + 5.6957208e7 * np.power(1.0 + n, 13) + + 5.242629e6 * np.power(1.0 + n, 14) + + 357504.0 * np.power(1.0 + n, 15) + + 17010.0 * np.power(1.0 + n, 16) + + 504.0 * np.power(1.0 + n, 17) + + 7.0 * np.power(1.0 + n, 18) ) / ( np.power(2.0 + n, 3) @@ -1393,46 +1355,16 @@ def F14(n, S1, S2, S21): * np.power(7.0 + n, 3) * np.power(8.0 + n, 3) ) - + S1 / np.power(1.0 + n, 2) - + ( - ( - 3.8402064e7 - + 1.38523392e8 * (1.0 + n) - + 2.26358048e8 * np.power(1.0 + n, 2) - + 2.20651312e8 * np.power(1.0 + n, 3) - + 1.42622963e8 * np.power(1.0 + n, 4) - + 6.434848e7 * np.power(1.0 + n, 5) - + 2.07774e7 * np.power(1.0 + n, 6) - + 4.838848e6 * np.power(1.0 + n, 7) - + 807086.0 * np.power(1.0 + n, 8) - + 94080.0 * np.power(1.0 + n, 9) - + 7280.0 * np.power(1.0 + n, 10) - + 336.0 * np.power(1.0 + n, 11) - + 7.0 * np.power(1.0 + n, 12) - ) - * (1 / (1.0 + n) + S1) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - ) - + S21 + + S3 ) ) / (8.0 + n) + n * ( - 6.0 / np.power(8.0 + n, 5) - - 3.2898681336964524 / np.power(8.0 + n, 3) - - 4.808227612638377 / np.power(8.0 + n, 2) - + 2.705808084277845 / (8.0 + n) - + ( - 6.0 + -1.0 / np.power(8.0 + n, 5) + + 1.0823232337111381 / (8.0 + n) + - ( + 1.0 * ( 1 / (1.0 + n) + ( @@ -1458,33 +1390,7 @@ def F14(n, S1, S2, S21): ) / np.power(8.0 + n, 4) - ( - 3.2898681336964524 - * ( - 1 / (1.0 + n) - + ( - (7.0 + 2.0 * (1.0 + n)) - * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - ) - + S1 - ) - ) - / np.power(8.0 + n, 2) - + ( - 4.0 + 1.0 * ( 0.5 * np.power( @@ -1539,39 +1445,59 @@ def F14(n, S1, S2, S21): ) ) / np.power(8.0 + n, 3) - + ( - 2.0 + - ( + 1.0 * ( - np.power(1.0 + n, -3) - + ( - 6.97339584e8 - + 3.525030432e9 * (1.0 + n) - + 8.293536336e9 * np.power(1.0 + n, 2) - + 1.2007529256e10 * np.power(1.0 + n, 3) - + 1.193375892e10 * np.power(1.0 + n, 4) - + 8.60864186e9 * np.power(1.0 + n, 5) - + 4.650892802e9 * np.power(1.0 + n, 6) - + 1.914862936e9 * np.power(1.0 + n, 7) - + 6.05522329e8 * np.power(1.0 + n, 8) - + 1.47044895e8 * np.power(1.0 + n, 9) - + 2.7198669e7 * np.power(1.0 + n, 10) - + 3.763711e6 * np.power(1.0 + n, 11) - + 377251.0 * np.power(1.0 + n, 12) - + 25865.0 * np.power(1.0 + n, 13) - + 1085.0 * np.power(1.0 + n, 14) - + 21.0 * np.power(1.0 + n, 15) + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1, + 3, ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 ) - + S1 / np.power(1.0 + n, 2) - + ( - ( + * ( + np.power(1.0 + n, -2) + + ( 773136.0 + 2.554272e6 * (1.0 + n) + 3.762752e6 * np.power(1.0 + n, 2) @@ -1584,17 +1510,49 @@ def F14(n, S1, S2, S21): + 210.0 * np.power(1.0 + n, 9) + 6.0 * np.power(1.0 + n, 10) ) - * (1 / (1.0 + n) + S1) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S2 ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 6.3467712e7 + + 2.75413824e8 * (1.0 + n) + + 5.54256432e8 * np.power(1.0 + n, 2) + + 6.84826352e8 * np.power(1.0 + n, 3) + + 5.79544028e8 * np.power(1.0 + n, 4) + + 3.54873092e8 * np.power(1.0 + n, 5) + + 1.61970683e8 * np.power(1.0 + n, 6) + + 5.5932611e7 * np.power(1.0 + n, 7) + + 1.4676674e7 * np.power(1.0 + n, 8) + + 2.911041e6 * np.power(1.0 + n, 9) + + 429534.0 * np.power(1.0 + n, 10) + + 45717.0 * np.power(1.0 + n, 11) + + 3318.0 * np.power(1.0 + n, 12) + + 147.0 * np.power(1.0 + n, 13) + + 3.0 * np.power(1.0 + n, 14) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + S3 ) - + S21 ) ) / np.power(8.0 + n, 2) @@ -1602,10 +1560,9 @@ def F14(n, S1, S2, S21): ) - 0.019847559824380426 * ( - 4.808227612638377 / (9.0 + n) - + ( - 3.2898681336964524 - * ( + ( + 0.16666666666666666 + * np.power( 1 / (1.0 + n) + ( 4.0 @@ -1630,122 +1587,39 @@ def F14(n, S1, S2, S21): * (8.0 + n) * (9.0 + n) ) - + S1 + + S1, + 3, ) - ) - / (9.0 + n) - - ( - 4.0 - * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 4.0 - * ( - 6.20783424e8 - + 2.402913888e9 * (1.0 + n) - + 4.261208648e9 * np.power(1.0 + n, 2) - + 4.5733464e9 * np.power(1.0 + n, 3) - + 3.31344237e9 * np.power(1.0 + n, 4) - + 1.713293694e9 * np.power(1.0 + n, 5) - + 6.51986769e8 * np.power(1.0 + n, 6) - + 1.85551632e8 * np.power(1.0 + n, 7) - + 3.9703709e7 * np.power(1.0 + n, 8) - + 6.360228e6 * np.power(1.0 + n, 9) - + 751317.0 * np.power(1.0 + n, 10) - + 63504.0 * np.power(1.0 + n, 11) - + 3633.0 * np.power(1.0 + n, 12) - + 126.0 * np.power(1.0 + n, 13) - + 2.0 * np.power(1.0 + n, 14) - ) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - ) - + S2 - ) - ) - ) - / np.power(9.0 + n, 2) - - ( - 2.0 + + 0.5 * ( - np.power(1.0 + n, -3) + 1 / (1.0 + n) + ( - 6.0 + 4.0 + * (9.0 + 2.0 * (1.0 + n)) * ( - 2.1452686055424e13 - + 1.27193972324352e14 * (1.0 + n) - + 3.569135825824e14 * np.power(1.0 + n, 2) - + 6.28964181904288e14 * np.power(1.0 + n, 3) - + 7.79557064653264e14 * np.power(1.0 + n, 4) - + 7.2173981400876e14 * np.power(1.0 + n, 5) - + 5.17717816384772e14 * np.power(1.0 + n, 6) - + 2.94648846212476e14 * np.power(1.0 + n, 7) - + 1.35183891860404e14 * np.power(1.0 + n, 8) - + 5.0528576648611e13 * np.power(1.0 + n, 9) - + 1.5487423206191e13 * np.power(1.0 + n, 10) - + 3.905253305568e12 * np.power(1.0 + n, 11) - + 8.10278287284e11 * np.power(1.0 + n, 12) - + 1.37943606892e11 * np.power(1.0 + n, 13) - + 1.9149259574e10 * np.power(1.0 + n, 14) - + 2.145327532e9 * np.power(1.0 + n, 15) - + 1.90913568e8 * np.power(1.0 + n, 16) - + 1.3175883e7 * np.power(1.0 + n, 17) - + 679567.0 * np.power(1.0 + n, 18) - + 24640.0 * np.power(1.0 + n, 19) - + 560.0 * np.power(1.0 + n, 20) - + 6.0 * np.power(1.0 + n, 21) + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) ) ) / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) ) - + S1 / np.power(1.0 + n, 2) + + S1 + ) + * ( + np.power(1.0 + n, -2) + ( 4.0 * ( @@ -1765,7 +1639,6 @@ def F14(n, S1, S2, S21): + 126.0 * np.power(1.0 + n, 13) + 2.0 * np.power(1.0 + n, 14) ) - * (1 / (1.0 + n) + S1) ) / ( np.power(2.0 + n, 2) @@ -1777,18 +1650,58 @@ def F14(n, S1, S2, S21): * np.power(8.0 + n, 2) * np.power(9.0 + n, 2) ) - + S21 + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 2.176131861504e12 + + 1.135056707712e13 * (1.0 + n) + + 2.7974661270464e13 * np.power(1.0 + n, 2) + + 4.3284545841312e13 * np.power(1.0 + n, 3) + + 4.7115984701808e13 * np.power(1.0 + n, 4) + + 3.8323387681704e13 * np.power(1.0 + n, 5) + + 2.4153337475604e13 * np.power(1.0 + n, 6) + + 1.2072584201292e13 * np.power(1.0 + n, 7) + + 4.858675624797e12 * np.power(1.0 + n, 8) + + 1.589624084295e12 * np.power(1.0 + n, 9) + + 4.25052833112e11 * np.power(1.0 + n, 10) + + 9.304706925e10 * np.power(1.0 + n, 11) + + 1.6646348871e10 * np.power(1.0 + n, 12) + + 2.420753526e9 * np.power(1.0 + n, 13) + + 2.8338678e8 * np.power(1.0 + n, 14) + + 2.6298432e7 * np.power(1.0 + n, 15) + + 1.889595e6 * np.power(1.0 + n, 16) + + 101331.0 * np.power(1.0 + n, 17) + + 3816.0 * np.power(1.0 + n, 18) + + 90.0 * np.power(1.0 + n, 19) + + np.power(1.0 + n, 20) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + + S3 ) ) / (9.0 + n) + n * ( - 6.0 / np.power(9.0 + n, 5) - - 3.2898681336964524 / np.power(9.0 + n, 3) - - 4.808227612638377 / np.power(9.0 + n, 2) - + 2.705808084277845 / (9.0 + n) - + ( - 6.0 + -1.0 / np.power(9.0 + n, 5) + + 1.0823232337111381 / (9.0 + n) + - ( + 1.0 * ( 1 / (1.0 + n) + ( @@ -1814,33 +1727,7 @@ def F14(n, S1, S2, S21): ) / np.power(9.0 + n, 4) - ( - 3.2898681336964524 - * ( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + S1 - ) - ) - / np.power(9.0 + n, 2) - + ( - 4.0 + 1.0 * ( 0.5 * np.power( @@ -1898,72 +1785,119 @@ def F14(n, S1, S2, S21): ) ) / np.power(9.0 + n, 3) - + ( - 2.0 + - ( + 1.0 * ( - np.power(1.0 + n, -3) - + ( - 2.0 - * ( - 1.22980964256e11 - + 6.79202212752e11 * (1.0 + n) - + 1.762986212232e12 * np.power(1.0 + n, 2) - + 2.849976037428e12 * np.power(1.0 + n, 3) - + 3.208712317944e12 * np.power(1.0 + n, 4) - + 2.66793900071e12 * np.power(1.0 + n, 5) - + 1.696140569839e12 * np.power(1.0 + n, 6) - + 8.42534361945e11 * np.power(1.0 + n, 7) - + 3.31394293594e11 * np.power(1.0 + n, 8) - + 1.03973066426e11 * np.power(1.0 + n, 9) - + 2.6083138284e10 * np.power(1.0 + n, 10) - + 5.220244242e9 * np.power(1.0 + n, 11) - + 8.27501148e8 * np.power(1.0 + n, 12) - + 1.02512358e8 * np.power(1.0 + n, 13) - + 9.709175e6 * np.power(1.0 + n, 14) - + 678601.0 * np.power(1.0 + n, 15) - + 32970.0 * np.power(1.0 + n, 16) - + 994.0 * np.power(1.0 + n, 17) - + 14.0 * np.power(1.0 + n, 18) + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) ) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - ) - + S1 / np.power(1.0 + n, 2) - + ( - ( - 3.8402064e7 - + 1.38523392e8 * (1.0 + n) - + 2.26358048e8 * np.power(1.0 + n, 2) - + 2.20651312e8 * np.power(1.0 + n, 3) - + 1.42622963e8 * np.power(1.0 + n, 4) - + 6.434848e7 * np.power(1.0 + n, 5) - + 2.07774e7 * np.power(1.0 + n, 6) - + 4.838848e6 * np.power(1.0 + n, 7) - + 807086.0 * np.power(1.0 + n, 8) - + 94080.0 * np.power(1.0 + n, 9) - + 7280.0 * np.power(1.0 + n, 10) - + 336.0 * np.power(1.0 + n, 11) - + 7.0 * np.power(1.0 + n, 12) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) ) - * (1 / (1.0 + n) + S1) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) + + S1, + 3, + ) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + * ( + np.power(1.0 + n, -2) + + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 1.52759224512e11 + + 7.72859090304e11 * (1.0 + n) + + 1.840340570544e12 * np.power(1.0 + n, 2) + + 2.738393029568e12 * np.power(1.0 + n, 3) + + 2.850741832092e12 * np.power(1.0 + n, 4) + + 2.203027167432e12 * np.power(1.0 + n, 5) + + 1.308849323187e12 * np.power(1.0 + n, 6) + + 6.10929168192e11 * np.power(1.0 + n, 7) + + 2.2702816521e11 * np.power(1.0 + n, 8) + + 6.7650709672e10 * np.power(1.0 + n, 9) + + 1.6200316881e10 * np.power(1.0 + n, 10) + + 3.110018688e9 * np.power(1.0 + n, 11) + + 4.75055e8 * np.power(1.0 + n, 12) + + 5.6957208e7 * np.power(1.0 + n, 13) + + 5.242629e6 * np.power(1.0 + n, 14) + + 357504.0 * np.power(1.0 + n, 15) + + 17010.0 * np.power(1.0 + n, 16) + + 504.0 * np.power(1.0 + n, 17) + + 7.0 * np.power(1.0 + n, 18) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + S3 ) - + S21 ) ) / np.power(9.0 + n, 2) @@ -1971,10 +1905,9 @@ def F14(n, S1, S2, S21): ) + 0.003243204652309423 * ( - 4.808227612638377 / (10.0 + n) - + ( - 3.2898681336964524 - * ( + ( + 0.16666666666666666 + * np.power( 1 / (1.0 + n) + ( 3.0 @@ -2001,131 +1934,41 @@ def F14(n, S1, S2, S21): * (9.0 + n) * (10.0 + n) ) - + S1 - ) - ) - / (10.0 + n) - - ( - 4.0 - * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 3.0 - * ( - 342192.0 - + 781800.0 * (1.0 + n) - + 723680.0 * np.power(1.0 + n, 2) - + 359100.0 * np.power(1.0 + n, 3) - + 105455.0 * np.power(1.0 + n, 4) - + 18900.0 * np.power(1.0 + n, 5) - + 2030.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 3.0 * np.power(1.0 + n, 8) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - ) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 3.0 - * ( - 6.7586510592e10 - + 2.7735912e11 * (1.0 + n) - + 5.25886236e11 * np.power(1.0 + n, 2) - + 6.098325648e11 * np.power(1.0 + n, 3) - + 4.8346372324e11 * np.power(1.0 + n, 4) - + 2.77716663e11 * np.power(1.0 + n, 5) - + 1.195744907e11 * np.power(1.0 + n, 6) - + 3.937668588e10 * np.power(1.0 + n, 7) - + 1.0027662147e10 * np.power(1.0 + n, 8) - + 1.982481e9 * np.power(1.0 + n, 9) - + 3.0344942e8 * np.power(1.0 + n, 10) - + 3.560508e7 * np.power(1.0 + n, 11) - + 3.141418e6 * np.power(1.0 + n, 12) - + 201600.0 * np.power(1.0 + n, 13) - + 8880.0 * np.power(1.0 + n, 14) - + 240.0 * np.power(1.0 + n, 15) - + 3.0 * np.power(1.0 + n, 16) - ) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - * np.power(10.0 + n, 2) - ) - + S2 - ) + + S1, + 3, ) - ) - / np.power(10.0 + n, 2) - - ( - 2.0 + + 0.5 * ( - np.power(1.0 + n, -3) + 1 / (1.0 + n) + ( 3.0 * ( - 3.183431862446899e16 - + 2.001696918700032e17 * (1.0 + n) - + 5.98808681111543e17 * np.power(1.0 + n, 2) - + 1.1319310863695514e18 * np.power(1.0 + n, 3) - + 1.5156493142882596e18 * np.power(1.0 + n, 4) - + 1.5282976372182676e18 * np.power(1.0 + n, 5) - + 1.2049970049036114e18 * np.power(1.0 + n, 6) - + 7.616938706128154e17 * np.power(1.0 + n, 7) - + 3.92747201355673e17 * np.power(1.0 + n, 8) - + 1.6722252430665453e17 * np.power(1.0 + n, 9) - + 5.92988929379218e16 * np.power(1.0 + n, 10) - + 1.7614071211379864e16 * np.power(1.0 + n, 11) - + 4.397465867910487e15 * np.power(1.0 + n, 12) - + 9.23902782587314e14 * np.power(1.0 + n, 13) - + 1.6322843101295e14 * np.power(1.0 + n, 14) - + 2.4179602098084e13 * np.power(1.0 + n, 15) - + 2.987313035113e12 * np.power(1.0 + n, 16) - + 3.05296487914e11 * np.power(1.0 + n, 17) - + 2.550145462e10 * np.power(1.0 + n, 18) - + 1.711289424e9 * np.power(1.0 + n, 19) - + 8.9968697e7 * np.power(1.0 + n, 20) - + 3.567374e6 * np.power(1.0 + n, 21) - + 100270.0 * np.power(1.0 + n, 22) - + 1780.0 * np.power(1.0 + n, 23) - + 15.0 * np.power(1.0 + n, 24) + 342192.0 + + 781800.0 * (1.0 + n) + + 723680.0 * np.power(1.0 + n, 2) + + 359100.0 * np.power(1.0 + n, 3) + + 105455.0 * np.power(1.0 + n, 4) + + 18900.0 * np.power(1.0 + n, 5) + + 2030.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) ) ) / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) - * np.power(10.0 + n, 3) + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) ) - + S1 / np.power(1.0 + n, 2) + + S1 + ) + * ( + np.power(1.0 + n, -2) + ( 3.0 * ( @@ -2147,7 +1990,6 @@ def F14(n, S1, S2, S21): + 240.0 * np.power(1.0 + n, 15) + 3.0 * np.power(1.0 + n, 16) ) - * (1 / (1.0 + n) + S1) ) / ( np.power(2.0 + n, 2) @@ -2160,18 +2002,62 @@ def F14(n, S1, S2, S21): * np.power(9.0 + n, 2) * np.power(10.0 + n, 2) ) - + S21 + + S2 + ) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 3.0 + * ( + 1.905865096469299e16 + + 1.100489126093568e17 * (1.0 + n) + + 3.026775163197197e17 * np.power(1.0 + n, 2) + + 5.274174874222368e17 * np.power(1.0 + n, 3) + + 6.532963289874519e17 * np.power(1.0 + n, 4) + + 6.118731135138024e17 * np.power(1.0 + n, 5) + + 4.5005054609223366e17 * np.power(1.0 + n, 6) + + 2.6656016992225488e17 * np.power(1.0 + n, 7) + + 1.2935179046741138e17 * np.power(1.0 + n, 8) + + 5.2054701631938e16 * np.power(1.0 + n, 9) + + 1.751929057804686e16 * np.power(1.0 + n, 10) + + 4.95861919609626e15 * np.power(1.0 + n, 11) + + 1.184087108357771e15 * np.power(1.0 + n, 12) + + 2.388131885349e14 * np.power(1.0 + n, 13) + + 4.064171822907e13 * np.power(1.0 + n, 14) + + 5.818192578e12 * np.power(1.0 + n, 15) + + 6.96833685225e11 * np.power(1.0 + n, 16) + + 6.92402094e10 * np.power(1.0 + n, 17) + + 5.63902616e9 * np.power(1.0 + n, 18) + + 3.699297e8 * np.power(1.0 + n, 19) + + 1.9060797e7 * np.power(1.0 + n, 20) + + 742500.0 * np.power(1.0 + n, 21) + + 20550.0 * np.power(1.0 + n, 22) + + 360.0 * np.power(1.0 + n, 23) + + 3.0 * np.power(1.0 + n, 24) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + * np.power(10.0 + n, 3) + ) + + S3 ) ) / (10.0 + n) + n * ( - 6.0 / np.power(10.0 + n, 5) - - 3.2898681336964524 / np.power(10.0 + n, 3) - - 4.808227612638377 / np.power(10.0 + n, 2) - + 2.705808084277845 / (10.0 + n) - + ( - 6.0 + -1.0 / np.power(10.0 + n, 5) + + 1.0823232337111381 / (10.0 + n) + - ( + 1.0 * ( 1 / (1.0 + n) + ( @@ -2202,38 +2088,7 @@ def F14(n, S1, S2, S21): ) / np.power(10.0 + n, 4) - ( - 3.2898681336964524 - * ( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1 - ) - ) - / np.power(10.0 + n, 2) - + ( - 4.0 + 1.0 * ( 0.5 * np.power( @@ -2302,80 +2157,142 @@ def F14(n, S1, S2, S21): ) ) / np.power(10.0 + n, 3) - + ( - 2.0 + - ( + 1.0 * ( - np.power(1.0 + n, -3) - + ( - 6.0 - * ( - 2.1452686055424e13 - + 1.27193972324352e14 * (1.0 + n) - + 3.569135825824e14 * np.power(1.0 + n, 2) - + 6.28964181904288e14 * np.power(1.0 + n, 3) - + 7.79557064653264e14 * np.power(1.0 + n, 4) - + 7.2173981400876e14 * np.power(1.0 + n, 5) - + 5.17717816384772e14 * np.power(1.0 + n, 6) - + 2.94648846212476e14 * np.power(1.0 + n, 7) - + 1.35183891860404e14 * np.power(1.0 + n, 8) - + 5.0528576648611e13 * np.power(1.0 + n, 9) - + 1.5487423206191e13 * np.power(1.0 + n, 10) - + 3.905253305568e12 * np.power(1.0 + n, 11) - + 8.10278287284e11 * np.power(1.0 + n, 12) - + 1.37943606892e11 * np.power(1.0 + n, 13) - + 1.9149259574e10 * np.power(1.0 + n, 14) - + 2.145327532e9 * np.power(1.0 + n, 15) - + 1.90913568e8 * np.power(1.0 + n, 16) - + 1.3175883e7 * np.power(1.0 + n, 17) - + 679567.0 * np.power(1.0 + n, 18) - + 24640.0 * np.power(1.0 + n, 19) - + 560.0 * np.power(1.0 + n, 20) - + 6.0 * np.power(1.0 + n, 21) + 0.16666666666666666 + * np.power( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) ) + + S1, + 3, ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) + + 0.5 + * ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 ) - + S1 / np.power(1.0 + n, 2) - + ( - 4.0 - * ( - 6.20783424e8 - + 2.402913888e9 * (1.0 + n) - + 4.261208648e9 * np.power(1.0 + n, 2) - + 4.5733464e9 * np.power(1.0 + n, 3) - + 3.31344237e9 * np.power(1.0 + n, 4) - + 1.713293694e9 * np.power(1.0 + n, 5) - + 6.51986769e8 * np.power(1.0 + n, 6) - + 1.85551632e8 * np.power(1.0 + n, 7) - + 3.9703709e7 * np.power(1.0 + n, 8) - + 6.360228e6 * np.power(1.0 + n, 9) - + 751317.0 * np.power(1.0 + n, 10) - + 63504.0 * np.power(1.0 + n, 11) - + 3633.0 * np.power(1.0 + n, 12) - + 126.0 * np.power(1.0 + n, 13) - + 2.0 * np.power(1.0 + n, 14) + * ( + np.power(1.0 + n, -2) + + ( + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) + ) ) - * (1 / (1.0 + n) + S1) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + S2 ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) + + 0.3333333333333333 + * ( + np.power(1.0 + n, -3) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 2.176131861504e12 + + 1.135056707712e13 * (1.0 + n) + + 2.7974661270464e13 * np.power(1.0 + n, 2) + + 4.3284545841312e13 * np.power(1.0 + n, 3) + + 4.7115984701808e13 * np.power(1.0 + n, 4) + + 3.8323387681704e13 * np.power(1.0 + n, 5) + + 2.4153337475604e13 * np.power(1.0 + n, 6) + + 1.2072584201292e13 * np.power(1.0 + n, 7) + + 4.858675624797e12 * np.power(1.0 + n, 8) + + 1.589624084295e12 * np.power(1.0 + n, 9) + + 4.25052833112e11 * np.power(1.0 + n, 10) + + 9.304706925e10 * np.power(1.0 + n, 11) + + 1.6646348871e10 * np.power(1.0 + n, 12) + + 2.420753526e9 * np.power(1.0 + n, 13) + + 2.8338678e8 * np.power(1.0 + n, 14) + + 2.6298432e7 * np.power(1.0 + n, 15) + + 1.889595e6 * np.power(1.0 + n, 16) + + 101331.0 * np.power(1.0 + n, 17) + + 3816.0 * np.power(1.0 + n, 18) + + 90.0 * np.power(1.0 + n, 19) + + np.power(1.0 + n, 20) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + + S3 ) - + S21 ) ) / np.power(10.0 + n, 2) @@ -2384,154 +2301,171 @@ def F14(n, S1, S2, S21): ) -@nb.njit("c16(c16,c16,c16)", cache=True) -def F11(n, S1, S2): +@nb.njit("c16(c16,c16)", cache=True) +def F9(n, S1): return ( - -0.1570209743051114 * n - - (0.4961137242141078 * n) / (2.0 + n) - + (0.14325154607236013 * n) / (3.0 + n) - + (0.043572446555835365 * n) / (4.0 + n) - - (0.1367619721729137 * n) / (5.0 + n) - + (0.5737638752229648 * n) / (6.0 + n) - - (1.6610332243741988 * n) / (7.0 + n) - + (3.333896376517311 * n) / (8.0 + n) - - (4.660416088583179 * n) / (9.0 + n) - + (4.454651830395971 * n) / (10.0 + n) - - (2.7814009672516686 * n) / (11.0 + n) - + (1.0238605215663694 * n) / (12.0 + n) - - (0.16899247190231767 * n) / (13.0 + n) - - 0.4887437258762844 * (-1.0 + 1 / (1.0 + n)) - - 1.0 + 0.06236473052300693 * n + + (0.2690947900632558 * n) / (2.0 + n) + - (0.12825410062391376 * n) / (3.0 + n) + + (0.007553694508943639 * n) / (4.0 + n) + + (0.030446610389993342 * n) / (5.0 + n) + - (0.11774020607944516 * n) / (6.0 + n) + + (0.33716180147388786 * n) / (7.0 + n) + - (0.6676623948212598 * n) / (8.0 + n) + + (0.9225597682535133 * n) / (9.0 + n) + - (0.8726283036193748 * n) / (10.0 + n) + + (0.5398117849858193 * n) / (11.0 + n) + - (0.1970839223372511 * n) / (12.0 + n) + + (0.03230590731253853 * n) / (13.0 + n) + + 0.21793029342350395 * (-1.0 + 1 / (1.0 + n)) + - 0.000925925925925926 * n * ( - -0.1570209813585035 - + 0.4166666666666667 / np.power(n, 3) - + 0.47941919157221546 / np.power(n, 2) - - 1.0 / np.power(1.0 + n, 3) - - 1.75 / np.power(1.0 + n, 2) - + 0.009326544681477866 / (1.0 + n) - + 0.75 / np.power(2.0 + n, 3) - + 1.25 / np.power(2.0 + n, 2) - + 0.8057445842680144 / (2.0 + n) - - 0.16666666666666666 / np.power(3.0 + n, 3) - - 0.25 / np.power(3.0 + n, 2) - - 0.13958627001930435 / (3.0 + n) - - (0.25 * (4.0 + 7.0 * (1.0 + n)) * S1) / np.power(1.0 + n, 2) - + (0.75 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 2) - + (1.25 * (1 / (1.0 + n) + S1)) / (2.0 + n) - - (0.16666666666666666 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) + 67.35391078053772 + + 993.5438760599122 / (1.0 + n) + + 185.10074515651877 / (2.0 + n) + - 21.841303653529422 / (3.0 + n) + + (180.0 * (1.0 + (1.0 + n) * S1)) / np.power(1.0 + n, 2) + - (180.0 * (1.0 + (2.0 + n) * (1 / (1.0 + n) + S1))) / np.power(2.0 + n, 2) + + (60.0 * (1.0 + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1))) / np.power(3.0 + n, 2) - - (0.25 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / (3.0 + n) - - ( - 0.002777777777777778 - * (22.59090896599757 - 172.59090896599758 * (1.0 + n)) - * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) - ) - / np.power(n, 2) - + ( - 0.75 - * ( - np.power(1.0 + n, -2) - + S1 / (1.0 + n) - + 0.5 * (np.power(S1, 2) + S2) - ) - ) - / (2.0 + n) - - ( - 1.0 - * ( - np.power(1.0 + n, -2) - + S1 / (1.0 + n) - - (1.0 * (1 / (1.0 + n) + S1)) / (1.0 + n) - + 0.5 * (np.power(S1, 2) + S2) - ) - ) - / (1.0 + n) - ( - 0.16666666666666666 - * ( - np.power(1.0 + n, -2) - + np.power(2.0 + n, -2) - + S1 / (1.0 + n) - + (1 / (1.0 + n) + S1) / (2.0 + n) - + 0.5 * (np.power(S1, 2) + S2) - ) - ) - / (3.0 + n) - + ( - 0.4166666666666667 + 1228.9090924080292 * ( - np.power(1.0 + n, -2) - + 1 / (n * (1.0 + n)) - + S1 / (1.0 + n) - + ((1.0 - 2.0 * (1.0 + n)) * (1 / (1.0 + n) + S1)) / (n * (1.0 + n)) - + 0.5 * (np.power(S1, 2) + S2) + 1.0 + + n + * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) ) ) - / n + / np.power(n, 2) ) ) -@nb.njit("c16(c16,c16,c16,c16)", cache=True) -def F18(n, S1, S2, S3): +@nb.njit("c16(c16,c16,c16,c16,c16,c16)", cache=True) +def F16(n, S1, Sm1, Sm2, Sm3, Sm21): return ( - 0.7502092979013981 + -0.23444040559418688 - 0.9999999952263307 * ( - n + -0.419833592426477 / (1.0 + n) + - (0.18119485915332012 * np.power(-1.0, 1.0 + n)) / (1.0 + n) + - (0.6010284515797971 * np.power(-1.0, 2.0 + n)) / (1.0 + n) + - (0.8224670334241131 * np.power(-1.0, 1.0 + n) * (1 / (1.0 + n) + S1)) + / (1.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 2.0 + n) + * (Sm1 - (1.0 * np.power(-1.0, n)) / (1.0 + n)) + ) + / (1.0 + n) + + ( + np.power(-1.0, 2.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + (1 / (1.0 + n) + S1) + * (Sm2 - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2)) + ) + ) + / (1.0 + n) + + n * ( - -1.0 / np.power(1.0 + n, 5) - + 1.0823232337111381 / (1.0 + n) - - (1.0 * S1) / np.power(1.0 + n, 4) - - (1.0 * (0.5 * np.power(S1, 2) + 0.5 * S2)) / np.power(1.0 + n, 3) - - ( - 1.0 + np.power(1.0 + n, -5) + - 0.8224670334241131 / np.power(1.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, n)) / np.power(1.0 + n, 3) + + 0.419833592426477 / np.power(1.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 1.0 + n)) / np.power(1.0 + n, 2) + - 0.3382260105347306 / (1.0 + n) + - (0.8224670334241131 * np.power(-1.0, n) * S1) / np.power(1.0 + n, 2) + - (0.8224670334241131 * np.power(-1.0, 1.0 + n) * Sm1) + / np.power(1.0 + n, 2) + + (np.power(-1.0, 1.0 + n) * Sm2) / np.power(1.0 + n, 3) + + ( + np.power(-1.0, 1.0 + n) * ( - 0.16666666666666666 * np.power(S1, 3) - + 0.5 * S1 * S2 - + 0.3333333333333333 * S3 + S1 * Sm2 + - 1.0 * Sm21 + + Sm3 + + np.power(-1.0, n) / np.power(1.0 + n, 3) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (1 / (1.0 + n) + S1) * np.power(-1.0, n)) + / np.power(1.0 + n, 2) ) ) / np.power(1.0 + n, 2) ) - + ( - 0.16666666666666666 * np.power(1 / (1.0 + n) + S1, 3) - + 0.5 * (1 / (1.0 + n) + S1) * (np.power(1.0 + n, -2) + S2) - + 0.3333333333333333 * (np.power(1.0 + n, -3) + S3) - ) - / (1.0 + n) ) + 0.49999902059348167 * ( - ( - 0.16666666666666666 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 3) - + 0.5 + -0.419833592426477 / (2.0 + n) + - (0.18119485915332012 * np.power(-1.0, 2.0 + n)) / (2.0 + n) + - (0.6010284515797971 * np.power(-1.0, 3.0 + n)) / (2.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 2.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) - * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) - + 0.3333333333333333 - * (np.power(1.0 + n, -3) + np.power(2.0 + n, -3) + S3) ) / (2.0 + n) - + n - * ( - -1.0 / np.power(2.0 + n, 5) - + 1.0823232337111381 / (2.0 + n) - - (1.0 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 4) - - ( - 1.0 + - ( + 0.8224670334241131 + * np.power(-1.0, 3.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + np.power(-1.0, n) / (2.0 + n) + ) + ) + / (2.0 + n) + + ( + np.power(-1.0, 3.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (1 / (1.0 + n) + S1) * np.power(-1.0, n)) + / np.power(2.0 + n, 2) + + (1 / (1.0 + n) + 1 / (2.0 + n) + S1) * ( - 0.5 * np.power(1 / (1.0 + n) + S1, 2) - + 0.5 * (np.power(1.0 + n, -2) + S2) + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + np.power(-1.0, n) / np.power(2.0 + n, 2) ) ) + ) + / (2.0 + n) + + n + * ( + np.power(2.0 + n, -5) + - 0.8224670334241131 / np.power(2.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 1.0 + n)) / np.power(2.0 + n, 3) + + 0.419833592426477 / np.power(2.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 1.0 + n)) / np.power(2.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 2.0 + n)) / np.power(2.0 + n, 2) + - 0.3382260105347306 / (2.0 + n) + - (0.8224670334241131 * np.power(-1.0, 1.0 + n) * (1 / (1.0 + n) + S1)) + / np.power(2.0 + n, 2) + + ( + np.power(-1.0, 2.0 + n) + * (Sm2 - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2)) + ) / np.power(2.0 + n, 3) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 2.0 + n) + * (Sm1 - (1.0 * np.power(-1.0, n)) / (1.0 + n)) + ) + / np.power(2.0 + n, 2) + + ( + np.power(-1.0, 2.0 + n) * ( - 0.16666666666666666 * np.power(1 / (1.0 + n) + S1, 3) - + 0.5 * (1 / (1.0 + n) + S1) * (np.power(1.0 + n, -2) + S2) - + 0.3333333333333333 * (np.power(1.0 + n, -3) + S3) + -1.0 * Sm21 + + Sm3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + (1 / (1.0 + n) + S1) + * (Sm2 - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2)) ) ) / np.power(2.0 + n, 2) @@ -2539,61 +2473,119 @@ def F18(n, S1, S2, S3): ) - 0.3332995604546604 * ( - ( - 0.16666666666666666 - * np.power( - 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) - + S1, - 3, - ) - + 0.5 + -0.419833592426477 / (3.0 + n) + - (0.18119485915332012 * np.power(-1.0, 3.0 + n)) / (3.0 + n) + - (0.6010284515797971 * np.power(-1.0, 4.0 + n)) / (3.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 3.0 + n) * ( 1 / (1.0 + n) + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + S1 ) + ) + / (3.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 4.0 + n) * ( - np.power(1.0 + n, -2) - + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) - + S2 + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + np.power(-1.0, n) / ((2.0 + n) * (3.0 + n)) ) - + 0.3333333333333333 + ) + / (3.0 + n) + + ( + np.power(-1.0, 4.0 + n) * ( - np.power(1.0 + n, -3) + -1.0 * Sm21 + + Sm3 + - ( + 1.0 + * (-7.0 - 9.0 * (1.0 + n) - 3.0 * np.power(1.0 + n, 2)) + * np.power(-1.0, n) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + ( - (3.0 + 2.0 * (1.0 + n)) - * (3.0 + 3.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ( + -5.0 + - 4.0 * (1.0 + n) + + np.power(1.0 + n, 2) + + np.power(1.0 + n, 3) + ) + * np.power(-1.0, n) ) / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) - + S3 - ) - ) - / (3.0 + n) - + n - * ( - -1.0 / np.power(3.0 + n, 5) - + 1.0823232337111381 / (3.0 + n) - - (1.0 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / np.power(3.0 + n, 4) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + (-3.0 - 2.0 * (1.0 + n)) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (-3.0 - 2.0 * (1.0 + n)) * np.power(-1.0, n)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + ) + ) + ) + / (3.0 + n) + + n + * ( + np.power(3.0 + n, -5) + - 0.8224670334241131 / np.power(3.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 2.0 + n)) / np.power(3.0 + n, 3) + + 0.419833592426477 / np.power(3.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 2.0 + n)) / np.power(3.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 3.0 + n)) / np.power(3.0 + n, 2) + - 0.3382260105347306 / (3.0 + n) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 2.0 + n) + * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + ) + / np.power(3.0 + n, 2) + + ( + np.power(-1.0, 3.0 + n) * ( - 0.5 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 2) - + 0.5 * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + np.power(-1.0, n) / np.power(2.0 + n, 2) ) ) / np.power(3.0 + n, 3) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 3.0 + n) * ( - 0.16666666666666666 - * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 3) - + 0.5 - * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) - * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) - + 0.3333333333333333 - * (np.power(1.0 + n, -3) + np.power(2.0 + n, -3) + S3) + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + np.power(-1.0, n) / (2.0 + n) + ) + ) + / np.power(3.0 + n, 2) + + ( + np.power(-1.0, 3.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (1 / (1.0 + n) + S1) * np.power(-1.0, n)) + / np.power(2.0 + n, 2) + + (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + np.power(-1.0, n) / np.power(2.0 + n, 2) + ) ) ) / np.power(3.0 + n, 2) @@ -2601,123 +2593,198 @@ def F18(n, S1, S2, S3): ) + 0.24954082848379078 * ( - ( - 0.16666666666666666 - * np.power( + -0.419833592426477 / (4.0 + n) + - (0.18119485915332012 * np.power(-1.0, 4.0 + n)) / (4.0 + n) + - (0.6010284515797971 * np.power(-1.0, 5.0 + n)) / (4.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 4.0 + n) + * ( 1 / (1.0 + n) + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) / ((2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1, - 3, + + S1 ) - + 0.5 + ) + / (4.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 5.0 + n) * ( - 1 / (1.0 + n) - + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * (-5.0 - 4.0 * (1.0 + n) - 1.0 * np.power(1.0 + n, 2)) + * np.power(-1.0, n) + ) / ((2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1 ) + ) + / (4.0 + n) + + ( + np.power(-1.0, 5.0 + n) * ( - np.power(1.0 + n, -2) + -1.0 * Sm21 + + Sm3 + ( - 49.0 - + 96.0 * (1.0 + n) - + 72.0 * np.power(1.0 + n, 2) - + 24.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) + ( + -179.0 + - 423.0 * (1.0 + n) + - 425.0 * np.power(1.0 + n, 2) + - 245.0 * np.power(1.0 + n, 3) + - 90.0 * np.power(1.0 + n, 4) + - 20.0 * np.power(1.0 + n, 5) + - 2.0 * np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) ) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) - + ( - 251.0 - + 684.0 * (1.0 + n) - + 795.0 * np.power(1.0 + n, 2) - + 504.0 * np.power(1.0 + n, 3) - + 183.0 * np.power(1.0 + n, 4) - + 36.0 * np.power(1.0 + n, 5) - + 3.0 * np.power(1.0 + n, 6) + - ( + 1.0 + * ( + -197.0 + - 468.0 * (1.0 + n) + - 453.0 * np.power(1.0 + n, 2) + - 232.0 * np.power(1.0 + n, 3) + - 69.0 * np.power(1.0 + n, 4) + - 12.0 * np.power(1.0 + n, 5) + - 1.0 * np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 3) * np.power(3.0 + n, 3) * np.power(4.0 + n, 3) ) - + S3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -31.0 + - 48.0 * (1.0 + n) + - 28.0 * np.power(1.0 + n, 2) + - 8.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -31.0 + - 48.0 * (1.0 + n) + - 28.0 * np.power(1.0 + n, 2) + - 8.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + ) ) ) / (4.0 + n) + n * ( - -1.0 / np.power(4.0 + n, 5) - + 1.0823232337111381 / (4.0 + n) + np.power(4.0 + n, -5) + - 0.8224670334241131 / np.power(4.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 3.0 + n)) / np.power(4.0 + n, 3) + + 0.419833592426477 / np.power(4.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 3.0 + n)) / np.power(4.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 4.0 + n)) / np.power(4.0 + n, 2) + - 0.3382260105347306 / (4.0 + n) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 3.0 + n) * ( 1 / (1.0 + n) + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + S1 ) ) - / np.power(4.0 + n, 4) + / np.power(4.0 + n, 2) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 4.0 + n) * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) - + S2 - ) + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + np.power(-1.0, n) / ((2.0 + n) * (3.0 + n)) + ) + ) + / np.power(4.0 + n, 2) + + ( + np.power(-1.0, 4.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (-3.0 - 2.0 * (1.0 + n)) * np.power(-1.0, n)) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) ) ) / np.power(4.0 + n, 3) - - ( - 1.0 + + ( + np.power(-1.0, 4.0 + n) * ( - 0.16666666666666666 - * np.power( - 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) - + S1, - 3, - ) - + 0.5 - * ( + -1.0 * Sm21 + + Sm3 + - ( + 1.0 + * (-7.0 - 9.0 * (1.0 + n) - 3.0 * np.power(1.0 + n, 2)) + * np.power(-1.0, n) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + ( + ( + -5.0 + - 4.0 * (1.0 + n) + + np.power(1.0 + n, 2) + + np.power(1.0 + n, 3) + ) + * np.power(-1.0, n) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + (-3.0 - 2.0 * (1.0 + n)) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + ( 1 / (1.0 + n) + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + S1 ) * ( - np.power(1.0 + n, -2) - + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - (1.0 * (-3.0 - 2.0 * (1.0 + n)) * np.power(-1.0, n)) / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) - + ( - (3.0 + 2.0 * (1.0 + n)) - * (3.0 + 3.0 * (1.0 + n) + np.power(1.0 + n, 2)) - ) - / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) - + S3 ) ) ) @@ -2726,9 +2793,13 @@ def F18(n, S1, S2, S3): ) - 0.1967571967137462 * ( - ( - 0.16666666666666666 - * np.power( + -0.419833592426477 / (5.0 + n) + - (0.18119485915332012 * np.power(-1.0, 5.0 + n)) / (5.0 + n) + - (0.6010284515797971 * np.power(-1.0, 6.0 + n)) / (5.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 5.0 + n) + * ( 1 / (1.0 + n) + ( 2.0 @@ -2736,59 +2807,65 @@ def F18(n, S1, S2, S3): * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) ) / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1, - 3, + + S1 ) - + 0.5 + ) + / (5.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 6.0 + n) * ( - 1 / (1.0 + n) + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + ( 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + * (7.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + * np.power(-1.0, n) ) / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1 ) + ) + / (5.0 + n) + + ( + np.power(-1.0, 6.0 + n) * ( - np.power(1.0 + n, -2) + -1.0 * Sm21 + + Sm3 + ( 2.0 * ( - 410.0 - + 1030.0 * (1.0 + n) - + 1081.0 * np.power(1.0 + n, 2) - + 600.0 * np.power(1.0 + n, 3) - + 185.0 * np.power(1.0 + n, 4) - + 30.0 * np.power(1.0 + n, 5) - + 2.0 * np.power(1.0 + n, 6) + 6196.0 + + 19110.0 * (1.0 + n) + + 25497.0 * np.power(1.0 + n, 2) + + 19295.0 * np.power(1.0 + n, 3) + + 9117.0 * np.power(1.0 + n, 4) + + 2775.0 * np.power(1.0 + n, 5) + + 535.0 * np.power(1.0 + n, 6) + + 60.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) ) + * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) ) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * ( - 1628.0 - + 5050.0 * (1.0 + n) - + 6935.0 * np.power(1.0 + n, 2) - + 5495.0 * np.power(1.0 + n, 3) - + 2737.0 * np.power(1.0 + n, 4) - + 875.0 * np.power(1.0 + n, 5) - + 175.0 * np.power(1.0 + n, 6) - + 20.0 * np.power(1.0 + n, 7) - + np.power(1.0 + n, 8) + ( + -9656.0 + - 26544.0 * (1.0 + n) + - 29682.0 * np.power(1.0 + n, 2) + - 16521.0 * np.power(1.0 + n, 3) + - 3745.0 * np.power(1.0 + n, 4) + + 787.0 * np.power(1.0 + n, 5) + + 793.0 * np.power(1.0 + n, 6) + + 236.0 * np.power(1.0 + n, 7) + + 34.0 * np.power(1.0 + n, 8) + + 2.0 * np.power(1.0 + n, 9) ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 3) @@ -2796,16 +2873,73 @@ def F18(n, S1, S2, S3): * np.power(4.0 + n, 3) * np.power(5.0 + n, 3) ) - + S3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 46.0 + + 70.0 * (1.0 + n) + + 39.0 * np.power(1.0 + n, 2) + + 10.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 46.0 + + 70.0 * (1.0 + n) + + 39.0 * np.power(1.0 + n, 2) + + 10.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + ) ) ) / (5.0 + n) + n * ( - -1.0 / np.power(5.0 + n, 5) - + 1.0823232337111381 / (5.0 + n) + np.power(5.0 + n, -5) + - 0.8224670334241131 / np.power(5.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 4.0 + n)) / np.power(5.0 + n, 3) + + 0.419833592426477 / np.power(5.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 4.0 + n)) / np.power(5.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 5.0 + n)) / np.power(5.0 + n, 2) + - 0.3382260105347306 / (5.0 + n) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 4.0 + n) * ( 1 / (1.0 + n) + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) @@ -2813,90 +2947,128 @@ def F18(n, S1, S2, S3): + S1 ) ) - / np.power(5.0 + n, 4) + / np.power(5.0 + n, 2) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 5.0 + n) * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1, - 2, + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * (-5.0 - 4.0 * (1.0 + n) - 1.0 * np.power(1.0 + n, 2)) + * np.power(-1.0, n) ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 49.0 - + 96.0 * (1.0 + n) - + 72.0 * np.power(1.0 + n, 2) - + 24.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + ) + ) + / np.power(5.0 + n, 2) + + ( + np.power(-1.0, 5.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -31.0 + - 48.0 * (1.0 + n) + - 28.0 * np.power(1.0 + n, 2) + - 8.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) ) - + S2 + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) ) ) ) / np.power(5.0 + n, 3) - - ( - 1.0 - * ( - 0.16666666666666666 - * np.power( - 1 / (1.0 + n) - + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1, - 3, + + ( + np.power(-1.0, 5.0 + n) + * ( + -1.0 * Sm21 + + Sm3 + + ( + ( + -179.0 + - 423.0 * (1.0 + n) + - 425.0 * np.power(1.0 + n, 2) + - 245.0 * np.power(1.0 + n, 3) + - 90.0 * np.power(1.0 + n, 4) + - 20.0 * np.power(1.0 + n, 5) + - 2.0 * np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) ) - + 0.5 - * ( + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + - ( + 1.0 + * ( + -197.0 + - 468.0 * (1.0 + n) + - 453.0 * np.power(1.0 + n, 2) + - 232.0 * np.power(1.0 + n, 3) + - 69.0 * np.power(1.0 + n, 4) + - 12.0 * np.power(1.0 + n, 5) + - 1.0 * np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -31.0 + - 48.0 * (1.0 + n) + - 28.0 * np.power(1.0 + n, 2) + - 8.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + ) + + ( 1 / (1.0 + n) + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + S1 ) * ( - np.power(1.0 + n, -2) - + ( - 49.0 - + 96.0 * (1.0 + n) - + 72.0 * np.power(1.0 + n, 2) - + 24.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -31.0 + - 48.0 * (1.0 + n) + - 28.0 * np.power(1.0 + n, 2) + - 8.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 2) * np.power(3.0 + n, 2) * np.power(4.0 + n, 2) ) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) - + ( - 251.0 - + 684.0 * (1.0 + n) - + 795.0 * np.power(1.0 + n, 2) - + 504.0 * np.power(1.0 + n, 3) - + 183.0 * np.power(1.0 + n, 4) - + 36.0 * np.power(1.0 + n, 5) - + 3.0 * np.power(1.0 + n, 6) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - ) - + S3 ) ) ) @@ -2905,9 +3077,13 @@ def F18(n, S1, S2, S3): ) + 0.1530503487172192 * ( - ( - 0.16666666666666666 - * np.power( + -0.419833592426477 / (6.0 + n) + - (0.18119485915332012 * np.power(-1.0, 6.0 + n)) / (6.0 + n) + - (0.6010284515797971 * np.power(-1.0, 7.0 + n)) / (6.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 6.0 + n) + * ( 1 / (1.0 + n) + ( 274.0 @@ -2917,61 +3093,79 @@ def F18(n, S1, S2, S3): + 5.0 * np.power(1.0 + n, 4) ) / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) - + S1, - 3, + + S1 ) - + 0.5 + ) + / (6.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 7.0 + n) * ( - 1 / (1.0 + n) - + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * ( + -94.0 + - 114.0 * (1.0 + n) + - 55.0 * np.power(1.0 + n, 2) + - 12.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) + ) + * np.power(-1.0, n) ) / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) - + S1 ) + ) + / (6.0 + n) + + ( + np.power(-1.0, 7.0 + n) * ( - np.power(1.0 + n, -2) + -1.0 * Sm21 + + Sm3 + ( - 21076.0 - + 62100.0 * (1.0 + n) - + 79650.0 * np.power(1.0 + n, 2) - + 57660.0 * np.power(1.0 + n, 3) - + 25685.0 * np.power(1.0 + n, 4) - + 7200.0 * np.power(1.0 + n, 5) - + 1240.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 5.0 * np.power(1.0 + n, 8) + ( + -1.364824e6 + - 4.959e6 * (1.0 + n) + - 8.21809e6 * np.power(1.0 + n, 2) + - 8.317171e6 * np.power(1.0 + n, 3) + - 5.805556e6 * np.power(1.0 + n, 4) + - 2.979747e6 * np.power(1.0 + n, 5) + - 1.160441e6 * np.power(1.0 + n, 6) + - 345225.0 * np.power(1.0 + n, 7) + - 77357.0 * np.power(1.0 + n, 8) + - 12617.0 * np.power(1.0 + n, 9) + - 1409.0 * np.power(1.0 + n, 10) + - 96.0 * np.power(1.0 + n, 11) + - 3.0 * np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) ) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) - + ( - 2.048824e6 - + 8.4339e6 * (1.0 + n) - + 1.595433e7 * np.power(1.0 + n, 2) - + 1.831824e7 * np.power(1.0 + n, 3) - + 1.419519e7 * np.power(1.0 + n, 4) - + 7.80975e6 * np.power(1.0 + n, 5) - + 3.124155e6 * np.power(1.0 + n, 6) - + 914760.0 * np.power(1.0 + n, 7) - + 194445.0 * np.power(1.0 + n, 8) - + 29250.0 * np.power(1.0 + n, 9) - + 2955.0 * np.power(1.0 + n, 10) - + 180.0 * np.power(1.0 + n, 11) - + 5.0 * np.power(1.0 + n, 12) + - ( + 1.0 + * ( + -1.562824e6 + - 5.7933e6 * (1.0 + n) + - 9.66711e6 * np.power(1.0 + n, 2) + - 9.628272e6 * np.power(1.0 + n, 3) + - 6.401058e6 * np.power(1.0 + n, 4) + - 3.007494e6 * np.power(1.0 + n, 5) + - 1.029715e6 * np.power(1.0 + n, 6) + - 260424.0 * np.power(1.0 + n, 7) + - 48597.0 * np.power(1.0 + n, 8) + - 6570.0 * np.power(1.0 + n, 9) + - 615.0 * np.power(1.0 + n, 10) + - 36.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 3) @@ -2980,86 +3174,203 @@ def F18(n, S1, S2, S3): * np.power(5.0 + n, 3) * np.power(6.0 + n, 3) ) - + S3 - ) - ) - / (6.0 + n) - + n - * ( - -1.0 / np.power(6.0 + n, 5) - + 1.0823232337111381 / (6.0 + n) - - ( - 1.0 - * ( - 1 / (1.0 + n) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -12076.0 + - 29100.0 * (1.0 + n) + - 30230.0 * np.power(1.0 + n, 2) + - 17964.0 * np.power(1.0 + n, 3) + - 6753.0 * np.power(1.0 + n, 4) + - 1656.0 * np.power(1.0 + n, 5) + - 260.0 * np.power(1.0 + n, 6) + - 24.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1 + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 ) - ) - / np.power(6.0 + n, 4) - - ( - 1.0 * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -12076.0 + - 29100.0 * (1.0 + n) + - 30230.0 * np.power(1.0 + n, 2) + - 17964.0 * np.power(1.0 + n, 3) + - 6753.0 * np.power(1.0 + n, 4) + - 1656.0 * np.power(1.0 + n, 5) + - 260.0 * np.power(1.0 + n, 6) + - 24.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1, - 2, + * np.power(-1.0, n) ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 2.0 - * ( - 410.0 - + 1030.0 * (1.0 + n) - + 1081.0 * np.power(1.0 + n, 2) - + 600.0 * np.power(1.0 + n, 3) - + 185.0 * np.power(1.0 + n, 4) - + 30.0 * np.power(1.0 + n, 5) - + 2.0 * np.power(1.0 + n, 6) - ) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + ) + ) + ) + / (6.0 + n) + + n + * ( + np.power(6.0 + n, -5) + - 0.8224670334241131 / np.power(6.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 5.0 + n)) / np.power(6.0 + n, 3) + + 0.419833592426477 / np.power(6.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 5.0 + n)) / np.power(6.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 6.0 + n)) / np.power(6.0 + n, 2) + - 0.3382260105347306 / (6.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 5.0 + n) + * ( + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + ) + / np.power(6.0 + n, 2) + - ( + 0.8224670334241131 + * np.power(-1.0, 6.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + ( + 2.0 + * (7.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + * np.power(-1.0, n) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + ) + ) + / np.power(6.0 + n, 2) + + ( + np.power(-1.0, 6.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 46.0 + + 70.0 * (1.0 + n) + + 39.0 * np.power(1.0 + n, 2) + + 10.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) ) - + S2 + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) ) ) ) / np.power(6.0 + n, 3) - - ( - 1.0 + + ( + np.power(-1.0, 6.0 + n) * ( - 0.16666666666666666 - * np.power( - 1 / (1.0 + n) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + -1.0 * Sm21 + + Sm3 + + ( + 2.0 + * ( + 6196.0 + + 19110.0 * (1.0 + n) + + 25497.0 * np.power(1.0 + n, 2) + + 19295.0 * np.power(1.0 + n, 3) + + 9117.0 * np.power(1.0 + n, 4) + + 2775.0 * np.power(1.0 + n, 5) + + 535.0 * np.power(1.0 + n, 6) + + 60.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1, - 3, + * np.power(-1.0, n) ) - + 0.5 - * ( + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + ( + ( + -9656.0 + - 26544.0 * (1.0 + n) + - 29682.0 * np.power(1.0 + n, 2) + - 16521.0 * np.power(1.0 + n, 3) + - 3745.0 * np.power(1.0 + n, 4) + + 787.0 * np.power(1.0 + n, 5) + + 793.0 * np.power(1.0 + n, 6) + + 236.0 * np.power(1.0 + n, 7) + + 34.0 * np.power(1.0 + n, 8) + + 2.0 * np.power(1.0 + n, 9) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * ( + 46.0 + + 70.0 * (1.0 + n) + + 39.0 * np.power(1.0 + n, 2) + + 10.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + ( 1 / (1.0 + n) + ( 2.0 @@ -3070,18 +3381,19 @@ def F18(n, S1, S2, S3): + S1 ) * ( - np.power(1.0 + n, -2) + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + ( 2.0 + * (5.0 + 2.0 * (1.0 + n)) * ( - 410.0 - + 1030.0 * (1.0 + n) - + 1081.0 * np.power(1.0 + n, 2) - + 600.0 * np.power(1.0 + n, 3) - + 185.0 * np.power(1.0 + n, 4) - + 30.0 * np.power(1.0 + n, 5) - + 2.0 * np.power(1.0 + n, 6) + 46.0 + + 70.0 * (1.0 + n) + + 39.0 * np.power(1.0 + n, 2) + + 10.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 2) @@ -3089,47 +3401,24 @@ def F18(n, S1, S2, S3): * np.power(4.0 + n, 2) * np.power(5.0 + n, 2) ) - + S2 ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * ( - 1628.0 - + 5050.0 * (1.0 + n) - + 6935.0 * np.power(1.0 + n, 2) - + 5495.0 * np.power(1.0 + n, 3) - + 2737.0 * np.power(1.0 + n, 4) - + 875.0 * np.power(1.0 + n, 5) - + 175.0 * np.power(1.0 + n, 6) - + 20.0 * np.power(1.0 + n, 7) - + np.power(1.0 + n, 8) - ) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - ) - + S3 - ) - ) - ) - / np.power(6.0 + n, 2) - ) - ) - - 0.10602798528818422 - * ( - ( - 0.16666666666666666 - * np.power( - 1 / (1.0 + n) - + ( - (7.0 + 2.0 * (1.0 + n)) + ) + ) + / np.power(6.0 + n, 2) + ) + ) + - 0.10602798528818422 + * ( + -0.419833592426477 / (7.0 + n) + - (0.18119485915332012 * np.power(-1.0, 7.0 + n)) / (7.0 + n) + - (0.6010284515797971 * np.power(-1.0, 8.0 + n)) / (7.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 7.0 + n) + * ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) * ( 252.0 + 392.0 * (1.0 + n) @@ -3146,21 +3435,26 @@ def F18(n, S1, S2, S3): * (6.0 + n) * (7.0 + n) ) - + S1, - 3, + + S1 ) - + 0.5 + ) + / (7.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 8.0 + n) * ( - 1 / (1.0 + n) + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + ( - (7.0 + 2.0 * (1.0 + n)) + 3.0 * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) + 148.0 + + 168.0 * (1.0 + n) + + 73.0 * np.power(1.0 + n, 2) + + 14.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) ) + * np.power(-1.0, n) ) / ( (2.0 + n) @@ -3170,55 +3464,63 @@ def F18(n, S1, S2, S3): * (6.0 + n) * (7.0 + n) ) - + S1 ) + ) + / (7.0 + n) + + ( + np.power(-1.0, 8.0 + n) * ( - np.power(1.0 + n, -2) + -1.0 * Sm21 + + Sm3 + ( - 773136.0 - + 2.554272e6 * (1.0 + n) - + 3.762752e6 * np.power(1.0 + n, 2) - + 3.23736e6 * np.power(1.0 + n, 3) - + 1.797035e6 * np.power(1.0 + n, 4) - + 671790.0 * np.power(1.0 + n, 5) - + 171248.0 * np.power(1.0 + n, 6) - + 29400.0 * np.power(1.0 + n, 7) - + 3255.0 * np.power(1.0 + n, 8) - + 210.0 * np.power(1.0 + n, 9) - + 6.0 * np.power(1.0 + n, 10) + 9.0 + * ( + 3.7315776e7 + + 1.56477888e8 * (1.0 + n) + + 3.00572848e8 * np.power(1.0 + n, 2) + + 3.51218448e8 * np.power(1.0 + n, 3) + + 2.79551676e8 * np.power(1.0 + n, 4) + + 1.60708716e8 * np.power(1.0 + n, 5) + + 6.8959587e7 * np.power(1.0 + n, 6) + + 2.2477189e7 * np.power(1.0 + n, 7) + + 5.600212e6 * np.power(1.0 + n, 8) + + 1.062467e6 * np.power(1.0 + n, 9) + + 151200.0 * np.power(1.0 + n, 10) + + 15659.0 * np.power(1.0 + n, 11) + + 1116.0 * np.power(1.0 + n, 12) + + 49.0 * np.power(1.0 + n, 13) + + np.power(1.0 + n, 14) + ) + * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) ) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) + ( - (7.0 + 2.0 * (1.0 + n)) - * ( - 6.3467712e7 - + 2.75413824e8 * (1.0 + n) - + 5.54256432e8 * np.power(1.0 + n, 2) - + 6.84826352e8 * np.power(1.0 + n, 3) - + 5.79544028e8 * np.power(1.0 + n, 4) - + 3.54873092e8 * np.power(1.0 + n, 5) - + 1.61970683e8 * np.power(1.0 + n, 6) - + 5.5932611e7 * np.power(1.0 + n, 7) - + 1.4676674e7 * np.power(1.0 + n, 8) - + 2.911041e6 * np.power(1.0 + n, 9) - + 429534.0 * np.power(1.0 + n, 10) - + 45717.0 * np.power(1.0 + n, 11) - + 3318.0 * np.power(1.0 + n, 12) - + 147.0 * np.power(1.0 + n, 13) - + 3.0 * np.power(1.0 + n, 14) + ( + -2.69400384e8 + - 1.055773152e9 * (1.0 + n) + - 1.862215728e9 * np.power(1.0 + n, 2) + - 1.946883032e9 * np.power(1.0 + n, 3) + - 1.328424984e9 * np.power(1.0 + n, 4) + - 6.04538588e8 * np.power(1.0 + n, 5) + - 1.71139894e8 * np.power(1.0 + n, 6) + - 1.745252e7 * np.power(1.0 + n, 7) + + 8.746623e6 * np.power(1.0 + n, 8) + + 5.172041e6 * np.power(1.0 + n, 9) + + 1.470723e6 * np.power(1.0 + n, 10) + + 270665.0 * np.power(1.0 + n, 11) + + 33685.0 * np.power(1.0 + n, 12) + + 2759.0 * np.power(1.0 + n, 13) + + 135.0 * np.power(1.0 + n, 14) + + 3.0 * np.power(1.0 + n, 15) ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 3) @@ -3228,16 +3530,97 @@ def F18(n, S1, S2, S3): * np.power(6.0 + n, 3) * np.power(7.0 + n, 3) ) - + S3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 3.0 + * (7.0 + 2.0 * (1.0 + n)) + * ( + 20016.0 + + 47936.0 * (1.0 + n) + + 49184.0 * np.power(1.0 + n, 2) + + 28560.0 * np.power(1.0 + n, 3) + + 10321.0 * np.power(1.0 + n, 4) + + 2380.0 * np.power(1.0 + n, 5) + + 342.0 * np.power(1.0 + n, 6) + + 28.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 3.0 + * (7.0 + 2.0 * (1.0 + n)) + * ( + 20016.0 + + 47936.0 * (1.0 + n) + + 49184.0 * np.power(1.0 + n, 2) + + 28560.0 * np.power(1.0 + n, 3) + + 10321.0 * np.power(1.0 + n, 4) + + 2380.0 * np.power(1.0 + n, 5) + + 342.0 * np.power(1.0 + n, 6) + + 28.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + ) ) ) / (7.0 + n) + n * ( - -1.0 / np.power(7.0 + n, 5) - + 1.0823232337111381 / (7.0 + n) + np.power(7.0 + n, -5) + - 0.8224670334241131 / np.power(7.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 6.0 + n)) / np.power(7.0 + n, 3) + + 0.419833592426477 / np.power(7.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 6.0 + n)) / np.power(7.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 7.0 + n)) / np.power(7.0 + n, 2) + - 0.3382260105347306 / (7.0 + n) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 6.0 + n) * ( 1 / (1.0 + n) + ( @@ -3251,81 +3634,138 @@ def F18(n, S1, S2, S3): + S1 ) ) - / np.power(7.0 + n, 4) + / np.power(7.0 + n, 2) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 7.0 + n) * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * ( + -94.0 + - 114.0 * (1.0 + n) + - 55.0 * np.power(1.0 + n, 2) + - 12.0 * np.power(1.0 + n, 3) + - 1.0 * np.power(1.0 + n, 4) ) - + S1, - 2, + * np.power(-1.0, n) ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 21076.0 - + 62100.0 * (1.0 + n) - + 79650.0 * np.power(1.0 + n, 2) - + 57660.0 * np.power(1.0 + n, 3) - + 25685.0 * np.power(1.0 + n, 4) - + 7200.0 * np.power(1.0 + n, 5) - + 1240.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 5.0 * np.power(1.0 + n, 8) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + ) + ) + / np.power(7.0 + n, 2) + + ( + np.power(-1.0, 7.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -12076.0 + - 29100.0 * (1.0 + n) + - 30230.0 * np.power(1.0 + n, 2) + - 17964.0 * np.power(1.0 + n, 3) + - 6753.0 * np.power(1.0 + n, 4) + - 1656.0 * np.power(1.0 + n, 5) + - 260.0 * np.power(1.0 + n, 6) + - 24.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) ) - + S2 + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) ) ) ) / np.power(7.0 + n, 3) - - ( - 1.0 + + ( + np.power(-1.0, 7.0 + n) * ( - 0.16666666666666666 - * np.power( - 1 / (1.0 + n) - + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) + -1.0 * Sm21 + + Sm3 + + ( + ( + -1.364824e6 + - 4.959e6 * (1.0 + n) + - 8.21809e6 * np.power(1.0 + n, 2) + - 8.317171e6 * np.power(1.0 + n, 3) + - 5.805556e6 * np.power(1.0 + n, 4) + - 2.979747e6 * np.power(1.0 + n, 5) + - 1.160441e6 * np.power(1.0 + n, 6) + - 345225.0 * np.power(1.0 + n, 7) + - 77357.0 * np.power(1.0 + n, 8) + - 12617.0 * np.power(1.0 + n, 9) + - 1409.0 * np.power(1.0 + n, 10) + - 96.0 * np.power(1.0 + n, 11) + - 3.0 * np.power(1.0 + n, 12) ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + - ( + 1.0 + * ( + -1.562824e6 + - 5.7933e6 * (1.0 + n) + - 9.66711e6 * np.power(1.0 + n, 2) + - 9.628272e6 * np.power(1.0 + n, 3) + - 6.401058e6 * np.power(1.0 + n, 4) + - 3.007494e6 * np.power(1.0 + n, 5) + - 1.029715e6 * np.power(1.0 + n, 6) + - 260424.0 * np.power(1.0 + n, 7) + - 48597.0 * np.power(1.0 + n, 8) + - 6570.0 * np.power(1.0 + n, 9) + - 615.0 * np.power(1.0 + n, 10) + - 36.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) ) - + S1, - 3, + * np.power(-1.0, n) ) - + 0.5 - * ( + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -12076.0 + - 29100.0 * (1.0 + n) + - 30230.0 * np.power(1.0 + n, 2) + - 17964.0 * np.power(1.0 + n, 3) + - 6753.0 * np.power(1.0 + n, 4) + - 1656.0 * np.power(1.0 + n, 5) + - 260.0 * np.power(1.0 + n, 6) + - 24.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + ( 1 / (1.0 + n) + ( 274.0 @@ -3344,17 +3784,22 @@ def F18(n, S1, S2, S3): + S1 ) * ( - np.power(1.0 + n, -2) - + ( - 21076.0 - + 62100.0 * (1.0 + n) - + 79650.0 * np.power(1.0 + n, 2) - + 57660.0 * np.power(1.0 + n, 3) - + 25685.0 * np.power(1.0 + n, 4) - + 7200.0 * np.power(1.0 + n, 5) - + 1240.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 5.0 * np.power(1.0 + n, 8) + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -12076.0 + - 29100.0 * (1.0 + n) + - 30230.0 * np.power(1.0 + n, 2) + - 17964.0 * np.power(1.0 + n, 3) + - 6753.0 * np.power(1.0 + n, 4) + - 1656.0 * np.power(1.0 + n, 5) + - 260.0 * np.power(1.0 + n, 6) + - 24.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 2) @@ -3363,34 +3808,6 @@ def F18(n, S1, S2, S3): * np.power(5.0 + n, 2) * np.power(6.0 + n, 2) ) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) - + ( - 2.048824e6 - + 8.4339e6 * (1.0 + n) - + 1.595433e7 * np.power(1.0 + n, 2) - + 1.831824e7 * np.power(1.0 + n, 3) - + 1.419519e7 * np.power(1.0 + n, 4) - + 7.80975e6 * np.power(1.0 + n, 5) - + 3.124155e6 * np.power(1.0 + n, 6) - + 914760.0 * np.power(1.0 + n, 7) - + 194445.0 * np.power(1.0 + n, 8) - + 29250.0 * np.power(1.0 + n, 9) - + 2955.0 * np.power(1.0 + n, 10) - + 180.0 * np.power(1.0 + n, 11) - + 5.0 * np.power(1.0 + n, 12) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - ) - + S3 ) ) ) @@ -3399,32 +3816,12 @@ def F18(n, S1, S2, S3): ) + 0.056951717764149916 * ( - ( - 0.16666666666666666 - * np.power( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + S1, - 3, - ) - + 0.5 + -0.419833592426477 / (8.0 + n) + - (0.18119485915332012 * np.power(-1.0, 8.0 + n)) / (8.0 + n) + - (0.6010284515797971 * np.power(-1.0, 9.0 + n)) / (8.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 8.0 + n) * ( 1 / (1.0 + n) + ( @@ -3447,57 +3844,68 @@ def F18(n, S1, S2, S3): ) + S1 ) - * ( - np.power(1.0 + n, -2) - + ( - 3.8402064e7 - + 1.38523392e8 * (1.0 + n) - + 2.26358048e8 * np.power(1.0 + n, 2) - + 2.20651312e8 * np.power(1.0 + n, 3) - + 1.42622963e8 * np.power(1.0 + n, 4) - + 6.434848e7 * np.power(1.0 + n, 5) - + 2.07774e7 * np.power(1.0 + n, 6) - + 4.838848e6 * np.power(1.0 + n, 7) - + 807086.0 * np.power(1.0 + n, 8) - + 94080.0 * np.power(1.0 + n, 9) - + 7280.0 * np.power(1.0 + n, 10) - + 336.0 * np.power(1.0 + n, 11) - + 7.0 * np.power(1.0 + n, 12) + ) + / (8.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 9.0 + n) + * ( + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * ( + -3828.0 + - 5736.0 * (1.0 + n) + - 3661.0 * np.power(1.0 + n, 2) + - 1248.0 * np.power(1.0 + n, 3) + - 238.0 * np.power(1.0 + n, 4) + - 24.0 * np.power(1.0 + n, 5) + - 1.0 * np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) ) - + S2 ) - + 0.3333333333333333 + ) + / (8.0 + n) + + ( + np.power(-1.0, 9.0 + n) * ( - np.power(1.0 + n, -3) - + ( - 1.52759224512e11 - + 7.72859090304e11 * (1.0 + n) - + 1.840340570544e12 * np.power(1.0 + n, 2) - + 2.738393029568e12 * np.power(1.0 + n, 3) - + 2.850741832092e12 * np.power(1.0 + n, 4) - + 2.203027167432e12 * np.power(1.0 + n, 5) - + 1.308849323187e12 * np.power(1.0 + n, 6) - + 6.10929168192e11 * np.power(1.0 + n, 7) - + 2.2702816521e11 * np.power(1.0 + n, 8) - + 6.7650709672e10 * np.power(1.0 + n, 9) - + 1.6200316881e10 * np.power(1.0 + n, 10) - + 3.110018688e9 * np.power(1.0 + n, 11) - + 4.75055e8 * np.power(1.0 + n, 12) - + 5.6957208e7 * np.power(1.0 + n, 13) - + 5.242629e6 * np.power(1.0 + n, 14) - + 357504.0 * np.power(1.0 + n, 15) - + 17010.0 * np.power(1.0 + n, 16) - + 504.0 * np.power(1.0 + n, 17) - + 7.0 * np.power(1.0 + n, 18) + -1.0 * Sm21 + + Sm3 + - ( + 1.0 + * ( + -1.15567048512e11 + - 5.35159384704e11 * (1.0 + n) + - 1.151188217424e12 * np.power(1.0 + n, 2) + - 1.53078715296e12 * np.power(1.0 + n, 3) + - 1.412584727652e12 * np.power(1.0 + n, 4) + - 9.62381167416e11 * np.power(1.0 + n, 5) + - 5.02598549197e11 * np.power(1.0 + n, 6) + - 2.0609943264e11 * np.power(1.0 + n, 7) + - 6.7393018182e10 * np.power(1.0 + n, 8) + - 1.7735954328e10 * np.power(1.0 + n, 9) + - 3.772650903e9 * np.power(1.0 + n, 10) + - 6.48395136e8 * np.power(1.0 + n, 11) + - 8.9565928e7 * np.power(1.0 + n, 12) + - 9.831528e6 * np.power(1.0 + n, 13) + - 840651.0 * np.power(1.0 + n, 14) + - 54144.0 * np.power(1.0 + n, 15) + - 2478.0 * np.power(1.0 + n, 16) + - 72.0 * np.power(1.0 + n, 17) + - 1.0 * np.power(1.0 + n, 18) + ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 3) @@ -3508,16 +3916,138 @@ def F18(n, S1, S2, S3): * np.power(7.0 + n, 3) * np.power(8.0 + n, 3) ) - + S3 + - ( + 2.0 + * ( + 4.9589391456e10 + + 2.24271058032e11 * (1.0 + n) + + 4.7403095628e11 * np.power(1.0 + n, 2) + + 6.25731974284e11 * np.power(1.0 + n, 3) + + 5.81676555432e11 * np.power(1.0 + n, 4) + + 4.0689079961e11 * np.power(1.0 + n, 5) + + 2.23175026185e11 * np.power(1.0 + n, 6) + + 9.8520885539e10 * np.power(1.0 + n, 7) + + 3.554804558e10 * np.power(1.0 + n, 8) + + 1.0556408108e10 * np.power(1.0 + n, 9) + + 2.579863556e9 * np.power(1.0 + n, 10) + + 5.15736142e8 * np.power(1.0 + n, 11) + + 8.3361904e7 * np.power(1.0 + n, 12) + + 1.0703902e7 * np.power(1.0 + n, 13) + + 1.064065e6 * np.power(1.0 + n, 14) + + 78795.0 * np.power(1.0 + n, 15) + + 4084.0 * np.power(1.0 + n, 16) + + 132.0 * np.power(1.0 + n, 17) + + 2.0 * np.power(1.0 + n, 18) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -2.1114864e7 + - 6.3635712e7 * (1.0 + n) + - 8.634864e7 * np.power(1.0 + n, 2) + - 7.024968e7 * np.power(1.0 + n, 3) + - 3.8347981e7 * np.power(1.0 + n, 4) + - 1.4846592e7 * np.power(1.0 + n, 5) + - 4.190576e6 * np.power(1.0 + n, 6) + - 870720.0 * np.power(1.0 + n, 7) + - 132426.0 * np.power(1.0 + n, 8) + - 14400.0 * np.power(1.0 + n, 9) + - 1064.0 * np.power(1.0 + n, 10) + - 48.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -2.1114864e7 + - 6.3635712e7 * (1.0 + n) + - 8.634864e7 * np.power(1.0 + n, 2) + - 7.024968e7 * np.power(1.0 + n, 3) + - 3.8347981e7 * np.power(1.0 + n, 4) + - 1.4846592e7 * np.power(1.0 + n, 5) + - 4.190576e6 * np.power(1.0 + n, 6) + - 870720.0 * np.power(1.0 + n, 7) + - 132426.0 * np.power(1.0 + n, 8) + - 14400.0 * np.power(1.0 + n, 9) + - 1064.0 * np.power(1.0 + n, 10) + - 48.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + ) ) ) / (8.0 + n) + n * ( - -1.0 / np.power(8.0 + n, 5) - + 1.0823232337111381 / (8.0 + n) + np.power(8.0 + n, -5) + - 0.8224670334241131 / np.power(8.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 7.0 + n)) / np.power(8.0 + n, 3) + + 0.419833592426477 / np.power(8.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 7.0 + n)) / np.power(8.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 8.0 + n)) / np.power(8.0 + n, 2) + - 0.3382260105347306 / (8.0 + n) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 7.0 + n) * ( 1 / (1.0 + n) + ( @@ -3541,92 +4071,157 @@ def F18(n, S1, S2, S3): + S1 ) ) - / np.power(8.0 + n, 4) + / np.power(8.0 + n, 2) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 8.0 + n) * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - (7.0 + 2.0 * (1.0 + n)) - * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + + ( + 3.0 + * ( + 148.0 + + 168.0 * (1.0 + n) + + 73.0 * np.power(1.0 + n, 2) + + 14.0 * np.power(1.0 + n, 3) + + np.power(1.0 + n, 4) ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - ) - + S1, - 2, + * np.power(-1.0, n) ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 773136.0 - + 2.554272e6 * (1.0 + n) - + 3.762752e6 * np.power(1.0 + n, 2) - + 3.23736e6 * np.power(1.0 + n, 3) - + 1.797035e6 * np.power(1.0 + n, 4) - + 671790.0 * np.power(1.0 + n, 5) - + 171248.0 * np.power(1.0 + n, 6) - + 29400.0 * np.power(1.0 + n, 7) - + 3255.0 * np.power(1.0 + n, 8) - + 210.0 * np.power(1.0 + n, 9) - + 6.0 * np.power(1.0 + n, 10) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + ) + ) + / np.power(8.0 + n, 2) + + ( + np.power(-1.0, 8.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 3.0 + * (7.0 + 2.0 * (1.0 + n)) + * ( + 20016.0 + + 47936.0 * (1.0 + n) + + 49184.0 * np.power(1.0 + n, 2) + + 28560.0 * np.power(1.0 + n, 3) + + 10321.0 * np.power(1.0 + n, 4) + + 2380.0 * np.power(1.0 + n, 5) + + 342.0 * np.power(1.0 + n, 6) + + 28.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) ) - + S2 + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) ) ) ) / np.power(8.0 + n, 3) - - ( - 1.0 + + ( + np.power(-1.0, 8.0 + n) * ( - 0.16666666666666666 - * np.power( - 1 / (1.0 + n) - + ( - (7.0 + 2.0 * (1.0 + n)) - * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) + -1.0 * Sm21 + + Sm3 + + ( + 9.0 + * ( + 3.7315776e7 + + 1.56477888e8 * (1.0 + n) + + 3.00572848e8 * np.power(1.0 + n, 2) + + 3.51218448e8 * np.power(1.0 + n, 3) + + 2.79551676e8 * np.power(1.0 + n, 4) + + 1.60708716e8 * np.power(1.0 + n, 5) + + 6.8959587e7 * np.power(1.0 + n, 6) + + 2.2477189e7 * np.power(1.0 + n, 7) + + 5.600212e6 * np.power(1.0 + n, 8) + + 1.062467e6 * np.power(1.0 + n, 9) + + 151200.0 * np.power(1.0 + n, 10) + + 15659.0 * np.power(1.0 + n, 11) + + 1116.0 * np.power(1.0 + n, 12) + + 49.0 * np.power(1.0 + n, 13) + + np.power(1.0 + n, 14) ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + ( + ( + -2.69400384e8 + - 1.055773152e9 * (1.0 + n) + - 1.862215728e9 * np.power(1.0 + n, 2) + - 1.946883032e9 * np.power(1.0 + n, 3) + - 1.328424984e9 * np.power(1.0 + n, 4) + - 6.04538588e8 * np.power(1.0 + n, 5) + - 1.71139894e8 * np.power(1.0 + n, 6) + - 1.745252e7 * np.power(1.0 + n, 7) + + 8.746623e6 * np.power(1.0 + n, 8) + + 5.172041e6 * np.power(1.0 + n, 9) + + 1.470723e6 * np.power(1.0 + n, 10) + + 270665.0 * np.power(1.0 + n, 11) + + 33685.0 * np.power(1.0 + n, 12) + + 2759.0 * np.power(1.0 + n, 13) + + 135.0 * np.power(1.0 + n, 14) + + 3.0 * np.power(1.0 + n, 15) ) - + S1, - 3, + * np.power(-1.0, n) ) - + 0.5 - * ( + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 3.0 + * (7.0 + 2.0 * (1.0 + n)) + * ( + 20016.0 + + 47936.0 * (1.0 + n) + + 49184.0 * np.power(1.0 + n, 2) + + 28560.0 * np.power(1.0 + n, 3) + + 10321.0 * np.power(1.0 + n, 4) + + 2380.0 * np.power(1.0 + n, 5) + + 342.0 * np.power(1.0 + n, 6) + + 28.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + ( 1 / (1.0 + n) + ( (7.0 + 2.0 * (1.0 + n)) @@ -3649,19 +4244,23 @@ def F18(n, S1, S2, S3): + S1 ) * ( - np.power(1.0 + n, -2) + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + ( - 773136.0 - + 2.554272e6 * (1.0 + n) - + 3.762752e6 * np.power(1.0 + n, 2) - + 3.23736e6 * np.power(1.0 + n, 3) - + 1.797035e6 * np.power(1.0 + n, 4) - + 671790.0 * np.power(1.0 + n, 5) - + 171248.0 * np.power(1.0 + n, 6) - + 29400.0 * np.power(1.0 + n, 7) - + 3255.0 * np.power(1.0 + n, 8) - + 210.0 * np.power(1.0 + n, 9) - + 6.0 * np.power(1.0 + n, 10) + 3.0 + * (7.0 + 2.0 * (1.0 + n)) + * ( + 20016.0 + + 47936.0 * (1.0 + n) + + 49184.0 * np.power(1.0 + n, 2) + + 28560.0 * np.power(1.0 + n, 3) + + 10321.0 * np.power(1.0 + n, 4) + + 2380.0 * np.power(1.0 + n, 5) + + 342.0 * np.power(1.0 + n, 6) + + 28.0 * np.power(1.0 + n, 7) + + np.power(1.0 + n, 8) + ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 2) @@ -3671,40 +4270,6 @@ def F18(n, S1, S2, S3): * np.power(6.0 + n, 2) * np.power(7.0 + n, 2) ) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) - + ( - (7.0 + 2.0 * (1.0 + n)) - * ( - 6.3467712e7 - + 2.75413824e8 * (1.0 + n) - + 5.54256432e8 * np.power(1.0 + n, 2) - + 6.84826352e8 * np.power(1.0 + n, 3) - + 5.79544028e8 * np.power(1.0 + n, 4) - + 3.54873092e8 * np.power(1.0 + n, 5) - + 1.61970683e8 * np.power(1.0 + n, 6) - + 5.5932611e7 * np.power(1.0 + n, 7) - + 1.4676674e7 * np.power(1.0 + n, 8) - + 2.911041e6 * np.power(1.0 + n, 9) - + 429534.0 * np.power(1.0 + n, 10) - + 45717.0 * np.power(1.0 + n, 11) - + 3318.0 * np.power(1.0 + n, 12) - + 147.0 * np.power(1.0 + n, 13) - + 3.0 * np.power(1.0 + n, 14) - ) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - ) - + S3 ) ) ) @@ -3713,9 +4278,13 @@ def F18(n, S1, S2, S3): ) - 0.019847559824380426 * ( - ( - 0.16666666666666666 - * np.power( + -0.419833592426477 / (9.0 + n) + - (0.18119485915332012 * np.power(-1.0, 9.0 + n)) / (9.0 + n) + - (0.6010284515797971 * np.power(-1.0, 10.0 + n)) / (9.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 9.0 + n) + * ( 1 / (1.0 + n) + ( 4.0 @@ -3740,24 +4309,28 @@ def F18(n, S1, S2, S3): * (8.0 + n) * (9.0 + n) ) - + S1, - 3, + + S1 ) - + 0.5 + ) + / (9.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 10.0 + n) * ( - 1 / (1.0 + n) + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + ( 4.0 - * (9.0 + 2.0 * (1.0 + n)) * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) + 6396.0 + + 9162.0 * (1.0 + n) + + 5473.0 * np.power(1.0 + n, 2) + + 1719.0 * np.power(1.0 + n, 3) + + 298.0 * np.power(1.0 + n, 4) + 27.0 * np.power(1.0 + n, 5) + np.power(1.0 + n, 6) ) + * np.power(-1.0, n) ) / ( (2.0 + n) @@ -3769,71 +4342,78 @@ def F18(n, S1, S2, S3): * (8.0 + n) * (9.0 + n) ) - + S1 ) + ) + / (9.0 + n) + + ( + np.power(-1.0, 10.0 + n) * ( - np.power(1.0 + n, -2) + -1.0 * Sm21 + + Sm3 + ( 4.0 * ( - 6.20783424e8 - + 2.402913888e9 * (1.0 + n) - + 4.261208648e9 * np.power(1.0 + n, 2) - + 4.5733464e9 * np.power(1.0 + n, 3) - + 3.31344237e9 * np.power(1.0 + n, 4) - + 1.713293694e9 * np.power(1.0 + n, 5) - + 6.51986769e8 * np.power(1.0 + n, 6) - + 1.85551632e8 * np.power(1.0 + n, 7) - + 3.9703709e7 * np.power(1.0 + n, 8) - + 6.360228e6 * np.power(1.0 + n, 9) - + 751317.0 * np.power(1.0 + n, 10) - + 63504.0 * np.power(1.0 + n, 11) - + 3633.0 * np.power(1.0 + n, 12) - + 126.0 * np.power(1.0 + n, 13) - + 2.0 * np.power(1.0 + n, 14) + 1.4760576193536e13 + + 7.3798658489088e13 * (1.0 + n) + + 1.72837443710016e14 * np.power(1.0 + n, 2) + + 2.52453402491616e14 * np.power(1.0 + n, 3) + + 2.5828967175624e14 * np.power(1.0 + n, 4) + + 1.97032446481464e14 * np.power(1.0 + n, 5) + + 1.16425369498108e14 * np.power(1.0 + n, 6) + + 5.4627507667116e13 * np.power(1.0 + n, 7) + + 2.0690074606371e13 * np.power(1.0 + n, 8) + + 6.392775359655e12 * np.power(1.0 + n, 9) + + 1.621160332314e12 * np.power(1.0 + n, 10) + + 3.38175413478e11 * np.power(1.0 + n, 11) + + 5.7948536701e10 * np.power(1.0 + n, 12) + + 8.115008166e9 * np.power(1.0 + n, 13) + + 9.1986012e8 * np.power(1.0 + n, 14) + + 8.3116584e7 * np.power(1.0 + n, 15) + + 5.847213e6 * np.power(1.0 + n, 16) + + 308691.0 * np.power(1.0 + n, 17) + + 11506.0 * np.power(1.0 + n, 18) + + 270.0 * np.power(1.0 + n, 19) + + 3.0 * np.power(1.0 + n, 20) ) + * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) ) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) + 2.0 * ( - 2.176131861504e12 - + 1.135056707712e13 * (1.0 + n) - + 2.7974661270464e13 * np.power(1.0 + n, 2) - + 4.3284545841312e13 * np.power(1.0 + n, 3) - + 4.7115984701808e13 * np.power(1.0 + n, 4) - + 3.8323387681704e13 * np.power(1.0 + n, 5) - + 2.4153337475604e13 * np.power(1.0 + n, 6) - + 1.2072584201292e13 * np.power(1.0 + n, 7) - + 4.858675624797e12 * np.power(1.0 + n, 8) - + 1.589624084295e12 * np.power(1.0 + n, 9) - + 4.25052833112e11 * np.power(1.0 + n, 10) - + 9.304706925e10 * np.power(1.0 + n, 11) - + 1.6646348871e10 * np.power(1.0 + n, 12) - + 2.420753526e9 * np.power(1.0 + n, 13) - + 2.8338678e8 * np.power(1.0 + n, 14) - + 2.6298432e7 * np.power(1.0 + n, 15) - + 1.889595e6 * np.power(1.0 + n, 16) - + 101331.0 * np.power(1.0 + n, 17) - + 3816.0 * np.power(1.0 + n, 18) - + 90.0 * np.power(1.0 + n, 19) - + np.power(1.0 + n, 20) + -2.3997963958272e13 + - 1.14129905965056e14 * (1.0 + n) + - 2.5222059905856e14 * np.power(1.0 + n, 2) + - 3.44033181492512e14 * np.power(1.0 + n, 3) + - 3.23935732772496e14 * np.power(1.0 + n, 4) + - 2.22502088875352e14 * np.power(1.0 + n, 5) + - 1.14348498644148e14 * np.power(1.0 + n, 6) + - 4.3968646592044e13 * np.power(1.0 + n, 7) + - 1.21438136977e13 * np.power(1.0 + n, 8) + - 2.010931672623e12 * np.power(1.0 + n, 9) + + 4.9482178305e10 * np.power(1.0 + n, 10) + + 1.59991878826e11 * np.power(1.0 + n, 11) + + 6.0723226806e10 * np.power(1.0 + n, 12) + + 1.4651858516e10 * np.power(1.0 + n, 13) + + 2.59766429e9 * np.power(1.0 + n, 14) + + 3.51680472e8 * np.power(1.0 + n, 15) + + 3.6575004e7 * np.power(1.0 + n, 16) + + 2.886025e6 * np.power(1.0 + n, 17) + + 167625.0 * np.power(1.0 + n, 18) + + 6770.0 * np.power(1.0 + n, 19) + + 170.0 * np.power(1.0 + n, 20) + + 2.0 * np.power(1.0 + n, 21) ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 3) @@ -3845,16 +4425,114 @@ def F18(n, S1, S2, S3): * np.power(8.0 + n, 3) * np.power(9.0 + n, 3) ) - + S3 + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3.6831936e7 + + 1.10670624e8 * (1.0 + n) + + 1.4936364e8 * np.power(1.0 + n, 2) + + 1.2041208e8 * np.power(1.0 + n, 3) + + 6.4783246e7 * np.power(1.0 + n, 4) + + 2.454111e7 * np.power(1.0 + n, 5) + + 6.715739e6 * np.power(1.0 + n, 6) + + 1.33785e6 * np.power(1.0 + n, 7) + + 192561.0 * np.power(1.0 + n, 8) + + 19530.0 * np.power(1.0 + n, 9) + + 1325.0 * np.power(1.0 + n, 10) + + 54.0 * np.power(1.0 + n, 11) + + np.power(1.0 + n, 12) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3.6831936e7 + + 1.10670624e8 * (1.0 + n) + + 1.4936364e8 * np.power(1.0 + n, 2) + + 1.2041208e8 * np.power(1.0 + n, 3) + + 6.4783246e7 * np.power(1.0 + n, 4) + + 2.454111e7 * np.power(1.0 + n, 5) + + 6.715739e6 * np.power(1.0 + n, 6) + + 1.33785e6 * np.power(1.0 + n, 7) + + 192561.0 * np.power(1.0 + n, 8) + + 19530.0 * np.power(1.0 + n, 9) + + 1325.0 * np.power(1.0 + n, 10) + + 54.0 * np.power(1.0 + n, 11) + + np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + ) ) ) / (9.0 + n) + n * ( - -1.0 / np.power(9.0 + n, 5) - + 1.0823232337111381 / (9.0 + n) + np.power(9.0 + n, -5) + - 0.8224670334241131 / np.power(9.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 8.0 + n)) / np.power(9.0 + n, 3) + + 0.419833592426477 / np.power(9.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 8.0 + n)) / np.power(9.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 9.0 + n)) / np.power(9.0 + n, 2) + - 0.3382260105347306 / (9.0 + n) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 8.0 + n) * ( 1 / (1.0 + n) + ( @@ -3878,95 +4556,177 @@ def F18(n, S1, S2, S3): + S1 ) ) - / np.power(9.0 + n, 4) + / np.power(9.0 + n, 2) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 9.0 + n) * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 + * ( + -3828.0 + - 5736.0 * (1.0 + n) + - 3661.0 * np.power(1.0 + n, 2) + - 1248.0 * np.power(1.0 + n, 3) + - 238.0 * np.power(1.0 + n, 4) + - 24.0 * np.power(1.0 + n, 5) + - 1.0 * np.power(1.0 + n, 6) ) - + S1, - 2, + * np.power(-1.0, n) ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 3.8402064e7 - + 1.38523392e8 * (1.0 + n) - + 2.26358048e8 * np.power(1.0 + n, 2) - + 2.20651312e8 * np.power(1.0 + n, 3) - + 1.42622963e8 * np.power(1.0 + n, 4) - + 6.434848e7 * np.power(1.0 + n, 5) - + 2.07774e7 * np.power(1.0 + n, 6) - + 4.838848e6 * np.power(1.0 + n, 7) - + 807086.0 * np.power(1.0 + n, 8) - + 94080.0 * np.power(1.0 + n, 9) - + 7280.0 * np.power(1.0 + n, 10) - + 336.0 * np.power(1.0 + n, 11) - + 7.0 * np.power(1.0 + n, 12) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + ) + ) + / np.power(9.0 + n, 2) + + ( + np.power(-1.0, 9.0 + n) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -2.1114864e7 + - 6.3635712e7 * (1.0 + n) + - 8.634864e7 * np.power(1.0 + n, 2) + - 7.024968e7 * np.power(1.0 + n, 3) + - 3.8347981e7 * np.power(1.0 + n, 4) + - 1.4846592e7 * np.power(1.0 + n, 5) + - 4.190576e6 * np.power(1.0 + n, 6) + - 870720.0 * np.power(1.0 + n, 7) + - 132426.0 * np.power(1.0 + n, 8) + - 14400.0 * np.power(1.0 + n, 9) + - 1064.0 * np.power(1.0 + n, 10) + - 48.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) ) - + S2 + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) ) ) ) / np.power(9.0 + n, 3) - - ( - 1.0 + + ( + np.power(-1.0, 9.0 + n) * ( - 0.16666666666666666 - * np.power( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) + -1.0 * Sm21 + + Sm3 + - ( + 1.0 + * ( + -1.15567048512e11 + - 5.35159384704e11 * (1.0 + n) + - 1.151188217424e12 * np.power(1.0 + n, 2) + - 1.53078715296e12 * np.power(1.0 + n, 3) + - 1.412584727652e12 * np.power(1.0 + n, 4) + - 9.62381167416e11 * np.power(1.0 + n, 5) + - 5.02598549197e11 * np.power(1.0 + n, 6) + - 2.0609943264e11 * np.power(1.0 + n, 7) + - 6.7393018182e10 * np.power(1.0 + n, 8) + - 1.7735954328e10 * np.power(1.0 + n, 9) + - 3.772650903e9 * np.power(1.0 + n, 10) + - 6.48395136e8 * np.power(1.0 + n, 11) + - 8.9565928e7 * np.power(1.0 + n, 12) + - 9.831528e6 * np.power(1.0 + n, 13) + - 840651.0 * np.power(1.0 + n, 14) + - 54144.0 * np.power(1.0 + n, 15) + - 2478.0 * np.power(1.0 + n, 16) + - 72.0 * np.power(1.0 + n, 17) + - 1.0 * np.power(1.0 + n, 18) ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + - ( + 2.0 + * ( + 4.9589391456e10 + + 2.24271058032e11 * (1.0 + n) + + 4.7403095628e11 * np.power(1.0 + n, 2) + + 6.25731974284e11 * np.power(1.0 + n, 3) + + 5.81676555432e11 * np.power(1.0 + n, 4) + + 4.0689079961e11 * np.power(1.0 + n, 5) + + 2.23175026185e11 * np.power(1.0 + n, 6) + + 9.8520885539e10 * np.power(1.0 + n, 7) + + 3.554804558e10 * np.power(1.0 + n, 8) + + 1.0556408108e10 * np.power(1.0 + n, 9) + + 2.579863556e9 * np.power(1.0 + n, 10) + + 5.15736142e8 * np.power(1.0 + n, 11) + + 8.3361904e7 * np.power(1.0 + n, 12) + + 1.0703902e7 * np.power(1.0 + n, 13) + + 1.064065e6 * np.power(1.0 + n, 14) + + 78795.0 * np.power(1.0 + n, 15) + + 4084.0 * np.power(1.0 + n, 16) + + 132.0 * np.power(1.0 + n, 17) + + 2.0 * np.power(1.0 + n, 18) ) - + S1, - 3, + * np.power(-1.0, n) ) - + 0.5 - * ( + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -2.1114864e7 + - 6.3635712e7 * (1.0 + n) + - 8.634864e7 * np.power(1.0 + n, 2) + - 7.024968e7 * np.power(1.0 + n, 3) + - 3.8347981e7 * np.power(1.0 + n, 4) + - 1.4846592e7 * np.power(1.0 + n, 5) + - 4.190576e6 * np.power(1.0 + n, 6) + - 870720.0 * np.power(1.0 + n, 7) + - 132426.0 * np.power(1.0 + n, 8) + - 14400.0 * np.power(1.0 + n, 9) + - 1064.0 * np.power(1.0 + n, 10) + - 48.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + ( 1 / (1.0 + n) + ( 13068.0 @@ -3989,21 +4749,26 @@ def F18(n, S1, S2, S3): + S1 ) * ( - np.power(1.0 + n, -2) - + ( - 3.8402064e7 - + 1.38523392e8 * (1.0 + n) - + 2.26358048e8 * np.power(1.0 + n, 2) - + 2.20651312e8 * np.power(1.0 + n, 3) - + 1.42622963e8 * np.power(1.0 + n, 4) - + 6.434848e7 * np.power(1.0 + n, 5) - + 2.07774e7 * np.power(1.0 + n, 6) - + 4.838848e6 * np.power(1.0 + n, 7) - + 807086.0 * np.power(1.0 + n, 8) - + 94080.0 * np.power(1.0 + n, 9) - + 7280.0 * np.power(1.0 + n, 10) - + 336.0 * np.power(1.0 + n, 11) - + 7.0 * np.power(1.0 + n, 12) + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -2.1114864e7 + - 6.3635712e7 * (1.0 + n) + - 8.634864e7 * np.power(1.0 + n, 2) + - 7.024968e7 * np.power(1.0 + n, 3) + - 3.8347981e7 * np.power(1.0 + n, 4) + - 1.4846592e7 * np.power(1.0 + n, 5) + - 4.190576e6 * np.power(1.0 + n, 6) + - 870720.0 * np.power(1.0 + n, 7) + - 132426.0 * np.power(1.0 + n, 8) + - 14400.0 * np.power(1.0 + n, 9) + - 1064.0 * np.power(1.0 + n, 10) + - 48.0 * np.power(1.0 + n, 11) + - 1.0 * np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 2) @@ -4014,42 +4779,6 @@ def F18(n, S1, S2, S3): * np.power(7.0 + n, 2) * np.power(8.0 + n, 2) ) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) - + ( - 1.52759224512e11 - + 7.72859090304e11 * (1.0 + n) - + 1.840340570544e12 * np.power(1.0 + n, 2) - + 2.738393029568e12 * np.power(1.0 + n, 3) - + 2.850741832092e12 * np.power(1.0 + n, 4) - + 2.203027167432e12 * np.power(1.0 + n, 5) - + 1.308849323187e12 * np.power(1.0 + n, 6) - + 6.10929168192e11 * np.power(1.0 + n, 7) - + 2.2702816521e11 * np.power(1.0 + n, 8) - + 6.7650709672e10 * np.power(1.0 + n, 9) - + 1.6200316881e10 * np.power(1.0 + n, 10) - + 3.110018688e9 * np.power(1.0 + n, 11) - + 4.75055e8 * np.power(1.0 + n, 12) - + 5.6957208e7 * np.power(1.0 + n, 13) - + 5.242629e6 * np.power(1.0 + n, 14) - + 357504.0 * np.power(1.0 + n, 15) - + 17010.0 * np.power(1.0 + n, 16) - + 504.0 * np.power(1.0 + n, 17) - + 7.0 * np.power(1.0 + n, 18) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - ) - + S3 ) ) ) @@ -4058,9 +4787,13 @@ def F18(n, S1, S2, S3): ) + 0.003243204652309423 * ( - ( - 0.16666666666666666 - * np.power( + -0.419833592426477 / (10.0 + n) + - (0.18119485915332012 * np.power(-1.0, 10.0 + n)) / (10.0 + n) + - (0.6010284515797971 * np.power(-1.0, 11.0 + n)) / (10.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 10.0 + n) + * ( 1 / (1.0 + n) + ( 3.0 @@ -4087,25 +4820,30 @@ def F18(n, S1, S2, S3): * (9.0 + n) * (10.0 + n) ) - + S1, - 3, + + S1 ) - + 0.5 + ) + / (10.0 + n) + - ( + 0.8224670334241131 + * np.power(-1.0, 11.0 + n) * ( - 1 / (1.0 + n) - + ( - 3.0 + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + - ( + 1.0 * ( - 342192.0 - + 781800.0 * (1.0 + n) - + 723680.0 * np.power(1.0 + n, 2) - + 359100.0 * np.power(1.0 + n, 3) - + 105455.0 * np.power(1.0 + n, 4) - + 18900.0 * np.power(1.0 + n, 5) - + 2030.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 3.0 * np.power(1.0 + n, 8) + -270576.0 + - 465000.0 * (1.0 + n) + - 351800.0 * np.power(1.0 + n, 2) + - 151060.0 * np.power(1.0 + n, 3) + - 40053.0 * np.power(1.0 + n, 4) + - 6700.0 * np.power(1.0 + n, 5) + - 690.0 * np.power(1.0 + n, 6) + - 40.0 * np.power(1.0 + n, 7) + - 1.0 * np.power(1.0 + n, 8) ) + * np.power(-1.0, n) ) / ( (2.0 + n) @@ -4118,77 +4856,85 @@ def F18(n, S1, S2, S3): * (9.0 + n) * (10.0 + n) ) - + S1 ) + ) + / (10.0 + n) + + ( + np.power(-1.0, 11.0 + n) * ( - np.power(1.0 + n, -2) + -1.0 * Sm21 + + Sm3 + ( - 3.0 - * ( - 6.7586510592e10 - + 2.7735912e11 * (1.0 + n) - + 5.25886236e11 * np.power(1.0 + n, 2) - + 6.098325648e11 * np.power(1.0 + n, 3) - + 4.8346372324e11 * np.power(1.0 + n, 4) - + 2.77716663e11 * np.power(1.0 + n, 5) - + 1.195744907e11 * np.power(1.0 + n, 6) - + 3.937668588e10 * np.power(1.0 + n, 7) - + 1.0027662147e10 * np.power(1.0 + n, 8) - + 1.982481e9 * np.power(1.0 + n, 9) - + 3.0344942e8 * np.power(1.0 + n, 10) - + 3.560508e7 * np.power(1.0 + n, 11) - + 3.141418e6 * np.power(1.0 + n, 12) - + 201600.0 * np.power(1.0 + n, 13) - + 8880.0 * np.power(1.0 + n, 14) - + 240.0 * np.power(1.0 + n, 15) - + 3.0 * np.power(1.0 + n, 16) + ( + -3.665793851814298e16 + - 1.909490377752576e17 * (1.0 + n) + - 4.70862544109472e17 * np.power(1.0 + n, 2) + - 7.33980385029854e17 * np.power(1.0 + n, 3) + - 8.148989973914079e17 * np.power(1.0 + n, 4) + - 6.882981306584479e17 * np.power(1.0 + n, 5) + - 4.611713296031033e17 * np.power(1.0 + n, 6) + - 2.5219843129581005e17 * np.power(1.0 + n, 7) + - 1.14842783872951e17 * np.power(1.0 + n, 8) + - 4.415488009076552e16 * np.power(1.0 + n, 9) + - 1.44652124073368e16 * np.power(1.0 + n, 10) + - 4.05880131245378e15 * np.power(1.0 + n, 11) + - 9.77306344262685e14 * np.power(1.0 + n, 12) + - 2.01769269859842e14 * np.power(1.0 + n, 13) + - 3.560081466145e13 * np.power(1.0 + n, 14) + - 5.339127383592e12 * np.power(1.0 + n, 15) + - 6.75333270995e11 * np.power(1.0 + n, 16) + - 7.1298201266e10 * np.power(1.0 + n, 17) + - 6.19612062e9 * np.power(1.0 + n, 18) + - 4.34978004e8 * np.power(1.0 + n, 19) + - 2.4024499e7 * np.power(1.0 + n, 20) + - 1.00395e6 * np.power(1.0 + n, 21) + - 29810.0 * np.power(1.0 + n, 22) + - 560.0 * np.power(1.0 + n, 23) + - 5.0 * np.power(1.0 + n, 24) ) + * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - * np.power(10.0 + n, 2) + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + * np.power(10.0 + n, 3) ) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) - + ( - 3.0 + - ( + 1.0 * ( - 1.905865096469299e16 - + 1.100489126093568e17 * (1.0 + n) - + 3.026775163197197e17 * np.power(1.0 + n, 2) - + 5.274174874222368e17 * np.power(1.0 + n, 3) - + 6.532963289874519e17 * np.power(1.0 + n, 4) - + 6.118731135138024e17 * np.power(1.0 + n, 5) - + 4.5005054609223366e17 * np.power(1.0 + n, 6) - + 2.6656016992225488e17 * np.power(1.0 + n, 7) - + 1.2935179046741138e17 * np.power(1.0 + n, 8) - + 5.2054701631938e16 * np.power(1.0 + n, 9) - + 1.751929057804686e16 * np.power(1.0 + n, 10) - + 4.95861919609626e15 * np.power(1.0 + n, 11) - + 1.184087108357771e15 * np.power(1.0 + n, 12) - + 2.388131885349e14 * np.power(1.0 + n, 13) - + 4.064171822907e13 * np.power(1.0 + n, 14) - + 5.818192578e12 * np.power(1.0 + n, 15) - + 6.96833685225e11 * np.power(1.0 + n, 16) - + 6.92402094e10 * np.power(1.0 + n, 17) - + 5.63902616e9 * np.power(1.0 + n, 18) - + 3.699297e8 * np.power(1.0 + n, 19) - + 1.9060797e7 * np.power(1.0 + n, 20) - + 742500.0 * np.power(1.0 + n, 21) - + 20550.0 * np.power(1.0 + n, 22) - + 360.0 * np.power(1.0 + n, 23) - + 3.0 * np.power(1.0 + n, 24) + -4.310738850111898e16 + - 2.300786211297024e17 * (1.0 + n) + - 5.793490942232486e17 * np.power(1.0 + n, 2) + - 9.169570554312557e17 * np.power(1.0 + n, 3) + - 1.0253555704764628e18 * np.power(1.0 + n, 4) + - 8.63111634551316e17 * np.power(1.0 + n, 5) + - 5.689117565311652e17 * np.power(1.0 + n, 6) + - 3.014933810188104e17 * np.power(1.0 + n, 7) + - 1.3085272169429526e17 * np.power(1.0 + n, 8) + - 4.712719391395e16 * np.power(1.0 + n, 9) + - 1.42167692592585e16 * np.power(1.0 + n, 10) + - 3.6154166212347e15 * np.power(1.0 + n, 11) + - 7.78200392291745e14 * np.power(1.0 + n, 12) + - 1.420469104479e14 * np.power(1.0 + n, 13) + - 2.198557186497e13 * np.power(1.0 + n, 14) + - 2.8791357052e12 * np.power(1.0 + n, 15) + - 3.17567574315e11 * np.power(1.0 + n, 16) + - 2.92849434e10 * np.power(1.0 + n, 17) + - 2.23273176e9 * np.power(1.0 + n, 18) + - 1.384419e8 * np.power(1.0 + n, 19) + - 6.812919e6 * np.power(1.0 + n, 20) + - 256300.0 * np.power(1.0 + n, 21) + - 6930.0 * np.power(1.0 + n, 22) + - 120.0 * np.power(1.0 + n, 23) + - 1.0 * np.power(1.0 + n, 24) ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 3) @@ -4201,640 +4947,324 @@ def F18(n, S1, S2, S3): * np.power(9.0 + n, 3) * np.power(10.0 + n, 3) ) - + S3 - ) - ) - / (10.0 + n) - + n - * ( - -1.0 / np.power(10.0 + n, 5) - + 1.0823232337111381 / (10.0 + n) - - ( - 1.0 - * ( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1 - ) - ) - / np.power(10.0 + n, 4) - - ( - 1.0 - * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1, - 2, + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + ( + -1.09027627776e11 + - 3.792865824e11 * (1.0 + n) + - 6.0713742384e11 * np.power(1.0 + n, 2) + - 5.9622705312e11 * np.power(1.0 + n, 3) + - 4.03242887656e11 * np.power(1.0 + n, 4) + - 1.99571643e11 * np.power(1.0 + n, 5) + - 7.48814979e10 * np.power(1.0 + n, 6) + - 2.175554084e10 * np.power(1.0 + n, 7) + - 4.951843521e9 * np.power(1.0 + n, 8) + - 8.86903e8 * np.power(1.0 + n, 9) + - 1.2470866e8 * np.power(1.0 + n, 10) + - 1.363476e7 * np.power(1.0 + n, 11) + - 1.137246e6 * np.power(1.0 + n, 12) + - 70000.0 * np.power(1.0 + n, 13) + - 3000.0 * np.power(1.0 + n, 14) + - 80.0 * np.power(1.0 + n, 15) + - 1.0 * np.power(1.0 + n, 16) ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 4.0 - * ( - 6.20783424e8 - + 2.402913888e9 * (1.0 + n) - + 4.261208648e9 * np.power(1.0 + n, 2) - + 4.5733464e9 * np.power(1.0 + n, 3) - + 3.31344237e9 * np.power(1.0 + n, 4) - + 1.713293694e9 * np.power(1.0 + n, 5) - + 6.51986769e8 * np.power(1.0 + n, 6) - + 1.85551632e8 * np.power(1.0 + n, 7) - + 3.9703709e7 * np.power(1.0 + n, 8) - + 6.360228e6 * np.power(1.0 + n, 9) - + 751317.0 * np.power(1.0 + n, 10) - + 63504.0 * np.power(1.0 + n, 11) - + 3633.0 * np.power(1.0 + n, 12) - + 126.0 * np.power(1.0 + n, 13) - + 2.0 * np.power(1.0 + n, 14) - ) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 3.0 + * ( + 342192.0 + + 781800.0 * (1.0 + n) + + 723680.0 * np.power(1.0 + n, 2) + + 359100.0 * np.power(1.0 + n, 3) + + 105455.0 * np.power(1.0 + n, 4) + + 18900.0 * np.power(1.0 + n, 5) + + 2030.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 1.0 + * ( + -1.09027627776e11 + - 3.792865824e11 * (1.0 + n) + - 6.0713742384e11 * np.power(1.0 + n, 2) + - 5.9622705312e11 * np.power(1.0 + n, 3) + - 4.03242887656e11 * np.power(1.0 + n, 4) + - 1.99571643e11 * np.power(1.0 + n, 5) + - 7.48814979e10 * np.power(1.0 + n, 6) + - 2.175554084e10 * np.power(1.0 + n, 7) + - 4.951843521e9 * np.power(1.0 + n, 8) + - 8.86903e8 * np.power(1.0 + n, 9) + - 1.2470866e8 * np.power(1.0 + n, 10) + - 1.363476e7 * np.power(1.0 + n, 11) + - 1.137246e6 * np.power(1.0 + n, 12) + - 70000.0 * np.power(1.0 + n, 13) + - 3000.0 * np.power(1.0 + n, 14) + - 80.0 * np.power(1.0 + n, 15) + - 1.0 * np.power(1.0 + n, 16) ) - + S2 + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) ) ) ) - / np.power(10.0 + n, 3) + ) + / (10.0 + n) + + n + * ( + np.power(10.0 + n, -5) + - 0.8224670334241131 / np.power(10.0 + n, 3) + - (0.8224670334241131 * np.power(-1.0, 9.0 + n)) / np.power(10.0 + n, 3) + + 0.419833592426477 / np.power(10.0 + n, 2) + + (1.6218904955860713 * np.power(-1.0, 9.0 + n)) / np.power(10.0 + n, 2) + + (1.2020569031595942 * np.power(-1.0, 10.0 + n)) + / np.power(10.0 + n, 2) + - 0.3382260105347306 / (10.0 + n) - ( - 1.0 + 0.8224670334241131 + * np.power(-1.0, 9.0 + n) * ( - 0.16666666666666666 - * np.power( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) ) - + S1, - 3, ) - + 0.5 - * ( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1 - ) - * ( - np.power(1.0 + n, -2) - + ( - 4.0 - * ( - 6.20783424e8 - + 2.402913888e9 * (1.0 + n) - + 4.261208648e9 * np.power(1.0 + n, 2) - + 4.5733464e9 * np.power(1.0 + n, 3) - + 3.31344237e9 * np.power(1.0 + n, 4) - + 1.713293694e9 * np.power(1.0 + n, 5) - + 6.51986769e8 * np.power(1.0 + n, 6) - + 1.85551632e8 * np.power(1.0 + n, 7) - + 3.9703709e7 * np.power(1.0 + n, 8) - + 6.360228e6 * np.power(1.0 + n, 9) - + 751317.0 * np.power(1.0 + n, 10) - + 63504.0 * np.power(1.0 + n, 11) - + 3633.0 * np.power(1.0 + n, 12) - + 126.0 * np.power(1.0 + n, 13) - + 2.0 * np.power(1.0 + n, 14) - ) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - ) - + S2 - ) - + 0.3333333333333333 - * ( - np.power(1.0 + n, -3) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 2.176131861504e12 - + 1.135056707712e13 * (1.0 + n) - + 2.7974661270464e13 * np.power(1.0 + n, 2) - + 4.3284545841312e13 * np.power(1.0 + n, 3) - + 4.7115984701808e13 * np.power(1.0 + n, 4) - + 3.8323387681704e13 * np.power(1.0 + n, 5) - + 2.4153337475604e13 * np.power(1.0 + n, 6) - + 1.2072584201292e13 * np.power(1.0 + n, 7) - + 4.858675624797e12 * np.power(1.0 + n, 8) - + 1.589624084295e12 * np.power(1.0 + n, 9) - + 4.25052833112e11 * np.power(1.0 + n, 10) - + 9.304706925e10 * np.power(1.0 + n, 11) - + 1.6646348871e10 * np.power(1.0 + n, 12) - + 2.420753526e9 * np.power(1.0 + n, 13) - + 2.8338678e8 * np.power(1.0 + n, 14) - + 2.6298432e7 * np.power(1.0 + n, 15) - + 1.889595e6 * np.power(1.0 + n, 16) - + 101331.0 * np.power(1.0 + n, 17) - + 3816.0 * np.power(1.0 + n, 18) - + 90.0 * np.power(1.0 + n, 19) - + np.power(1.0 + n, 20) - ) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) - ) - + S3 + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) ) + + S1 ) ) / np.power(10.0 + n, 2) - ) - ) - ) - - -@nb.njit("c16(c16,c16,c16)", cache=True) -def F12(n, S1, S2): - return ( - 0.18755232447534953 - - 0.9999999952263307 - * ( - 1.2020569031595942 / (1.0 + n) - + n - * ( - np.power(1.0 + n, -5) - - 1.2020569031595942 / np.power(1.0 + n, 2) - + 0.27058080842778454 / (1.0 + n) - + S1 / np.power(1.0 + n, 4) - + (0.5 * np.power(S1, 2) + 0.5 * S2) / np.power(1.0 + n, 3) - ) - - ( - 1.0 - * ( - 0.5 * np.power(1 / (1.0 + n) + S1, 2) - + 0.5 * (np.power(1.0 + n, -2) + S2) - ) - ) - / np.power(1.0 + n, 2) - ) - + 0.49999902059348167 - * ( - 1.2020569031595942 / (2.0 + n) - - ( - 1.0 - * ( - 0.5 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 2) - + 0.5 * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) - ) - ) - / np.power(2.0 + n, 2) - + n - * ( - np.power(2.0 + n, -5) - - 1.2020569031595942 / np.power(2.0 + n, 2) - + 0.27058080842778454 / (2.0 + n) - + (1 / (1.0 + n) + S1) / np.power(2.0 + n, 4) - + ( - 0.5 * np.power(1 / (1.0 + n) + S1, 2) - + 0.5 * (np.power(1.0 + n, -2) + S2) - ) - / np.power(2.0 + n, 3) - ) - ) - - 0.3332995604546604 - * ( - 1.2020569031595942 / (3.0 + n) - - ( - 1.0 - * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) - + S2 - ) - ) - ) - / np.power(3.0 + n, 2) - + n - * ( - np.power(3.0 + n, -5) - - 1.2020569031595942 / np.power(3.0 + n, 2) - + 0.27058080842778454 / (3.0 + n) - + (1 / (1.0 + n) + 1 / (2.0 + n) + S1) / np.power(3.0 + n, 4) - + ( - 0.5 * np.power(1 / (1.0 + n) + 1 / (2.0 + n) + S1, 2) - + 0.5 * (np.power(1.0 + n, -2) + np.power(2.0 + n, -2) + S2) - ) - / np.power(3.0 + n, 3) - ) - ) - + 0.24954082848379078 - * ( - 1.2020569031595942 / (4.0 + n) - - ( - 1.0 - * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1, - 2, - ) - + 0.5 + - ( + 0.8224670334241131 + * np.power(-1.0, 10.0 + n) * ( - np.power(1.0 + n, -2) + Sm1 + - (1.0 * np.power(-1.0, n)) / (1.0 + n) + ( - 49.0 - + 96.0 * (1.0 + n) - + 72.0 * np.power(1.0 + n, 2) - + 24.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) + 4.0 + * ( + 6396.0 + + 9162.0 * (1.0 + n) + + 5473.0 * np.power(1.0 + n, 2) + + 1719.0 * np.power(1.0 + n, 3) + + 298.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) ) - + S2 ) ) - ) - / np.power(4.0 + n, 2) - + n - * ( - np.power(4.0 + n, -5) - - 1.2020569031595942 / np.power(4.0 + n, 2) - + 0.27058080842778454 / (4.0 + n) - + ( - 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) - + S1 - ) - / np.power(4.0 + n, 4) + / np.power(10.0 + n, 2) + ( - 0.5 - * np.power( - 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) - + S2 - ) - ) - / np.power(4.0 + n, 3) - ) - ) - - 0.1967571967137462 - * ( - 1.2020569031595942 / (5.0 + n) - - ( - 1.0 - * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1, - 2, - ) - + 0.5 + np.power(-1.0, 10.0 + n) * ( - np.power(1.0 + n, -2) + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + ( - 2.0 + 4.0 + * (9.0 + 2.0 * (1.0 + n)) * ( - 410.0 - + 1030.0 * (1.0 + n) - + 1081.0 * np.power(1.0 + n, 2) - + 600.0 * np.power(1.0 + n, 3) - + 185.0 * np.power(1.0 + n, 4) - + 30.0 * np.power(1.0 + n, 5) - + 2.0 * np.power(1.0 + n, 6) + 3.6831936e7 + + 1.10670624e8 * (1.0 + n) + + 1.4936364e8 * np.power(1.0 + n, 2) + + 1.2041208e8 * np.power(1.0 + n, 3) + + 6.4783246e7 * np.power(1.0 + n, 4) + + 2.454111e7 * np.power(1.0 + n, 5) + + 6.715739e6 * np.power(1.0 + n, 6) + + 1.33785e6 * np.power(1.0 + n, 7) + + 192561.0 * np.power(1.0 + n, 8) + + 19530.0 * np.power(1.0 + n, 9) + + 1325.0 * np.power(1.0 + n, 10) + + 54.0 * np.power(1.0 + n, 11) + + np.power(1.0 + n, 12) ) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 2) * np.power(3.0 + n, 2) * np.power(4.0 + n, 2) * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) ) - + S2 ) ) - ) - / np.power(5.0 + n, 2) - + n - * ( - np.power(5.0 + n, -5) - - 1.2020569031595942 / np.power(5.0 + n, 2) - + 0.27058080842778454 / (5.0 + n) - + ( - 1 / (1.0 + n) - + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1 - ) - / np.power(5.0 + n, 4) + / np.power(10.0 + n, 3) + ( - 0.5 - * np.power( - 1 / (1.0 + n) - + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1, - 2, - ) - + 0.5 + np.power(-1.0, 10.0 + n) * ( - np.power(1.0 + n, -2) + -1.0 * Sm21 + + Sm3 + ( - 49.0 - + 96.0 * (1.0 + n) - + 72.0 * np.power(1.0 + n, 2) - + 24.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - ) - + S2 - ) - ) - / np.power(5.0 + n, 3) - ) - ) - + 0.1530503487172192 - * ( - 1.2020569031595942 / (6.0 + n) - - ( - 1.0 - * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 21076.0 - + 62100.0 * (1.0 + n) - + 79650.0 * np.power(1.0 + n, 2) - + 57660.0 * np.power(1.0 + n, 3) - + 25685.0 * np.power(1.0 + n, 4) - + 7200.0 * np.power(1.0 + n, 5) - + 1240.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 5.0 * np.power(1.0 + n, 8) + 4.0 + * ( + 1.4760576193536e13 + + 7.3798658489088e13 * (1.0 + n) + + 1.72837443710016e14 * np.power(1.0 + n, 2) + + 2.52453402491616e14 * np.power(1.0 + n, 3) + + 2.5828967175624e14 * np.power(1.0 + n, 4) + + 1.97032446481464e14 * np.power(1.0 + n, 5) + + 1.16425369498108e14 * np.power(1.0 + n, 6) + + 5.4627507667116e13 * np.power(1.0 + n, 7) + + 2.0690074606371e13 * np.power(1.0 + n, 8) + + 6.392775359655e12 * np.power(1.0 + n, 9) + + 1.621160332314e12 * np.power(1.0 + n, 10) + + 3.38175413478e11 * np.power(1.0 + n, 11) + + 5.7948536701e10 * np.power(1.0 + n, 12) + + 8.115008166e9 * np.power(1.0 + n, 13) + + 9.1986012e8 * np.power(1.0 + n, 14) + + 8.3116584e7 * np.power(1.0 + n, 15) + + 5.847213e6 * np.power(1.0 + n, 16) + + 308691.0 * np.power(1.0 + n, 17) + + 11506.0 * np.power(1.0 + n, 18) + + 270.0 * np.power(1.0 + n, 19) + + 3.0 * np.power(1.0 + n, 20) + ) + * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - ) - + S2 - ) - ) - ) - / np.power(6.0 + n, 2) - + n - * ( - np.power(6.0 + n, -5) - - 1.2020569031595942 / np.power(6.0 + n, 2) - + 0.27058080842778454 / (6.0 + n) - + ( - 1 / (1.0 + n) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1 - ) - / np.power(6.0 + n, 4) - + ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) + ( 2.0 * ( - 410.0 - + 1030.0 * (1.0 + n) - + 1081.0 * np.power(1.0 + n, 2) - + 600.0 * np.power(1.0 + n, 3) - + 185.0 * np.power(1.0 + n, 4) - + 30.0 * np.power(1.0 + n, 5) - + 2.0 * np.power(1.0 + n, 6) + -2.3997963958272e13 + - 1.14129905965056e14 * (1.0 + n) + - 2.5222059905856e14 * np.power(1.0 + n, 2) + - 3.44033181492512e14 * np.power(1.0 + n, 3) + - 3.23935732772496e14 * np.power(1.0 + n, 4) + - 2.22502088875352e14 * np.power(1.0 + n, 5) + - 1.14348498644148e14 * np.power(1.0 + n, 6) + - 4.3968646592044e13 * np.power(1.0 + n, 7) + - 1.21438136977e13 * np.power(1.0 + n, 8) + - 2.010931672623e12 * np.power(1.0 + n, 9) + + 4.9482178305e10 * np.power(1.0 + n, 10) + + 1.59991878826e11 * np.power(1.0 + n, 11) + + 6.0723226806e10 * np.power(1.0 + n, 12) + + 1.4651858516e10 * np.power(1.0 + n, 13) + + 2.59766429e9 * np.power(1.0 + n, 14) + + 3.51680472e8 * np.power(1.0 + n, 15) + + 3.6575004e7 * np.power(1.0 + n, 16) + + 2.886025e6 * np.power(1.0 + n, 17) + + 167625.0 * np.power(1.0 + n, 18) + + 6770.0 * np.power(1.0 + n, 19) + + 170.0 * np.power(1.0 + n, 20) + + 2.0 * np.power(1.0 + n, 21) ) + * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) ) - + S2 - ) - ) - / np.power(6.0 + n, 3) - ) - ) - - 0.10602798528818422 - * ( - 1.2020569031595942 / (7.0 + n) - - ( - 1.0 - * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - (7.0 + 2.0 * (1.0 + n)) + + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + - ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) + 3.6831936e7 + + 1.10670624e8 * (1.0 + n) + + 1.4936364e8 * np.power(1.0 + n, 2) + + 1.2041208e8 * np.power(1.0 + n, 3) + + 6.4783246e7 * np.power(1.0 + n, 4) + + 2.454111e7 * np.power(1.0 + n, 5) + + 6.715739e6 * np.power(1.0 + n, 6) + + 1.33785e6 * np.power(1.0 + n, 7) + + 192561.0 * np.power(1.0 + n, 8) + + 19530.0 * np.power(1.0 + n, 9) + + 1325.0 * np.power(1.0 + n, 10) + + 54.0 * np.power(1.0 + n, 11) + + np.power(1.0 + n, 12) ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - ) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 773136.0 - + 2.554272e6 * (1.0 + n) - + 3.762752e6 * np.power(1.0 + n, 2) - + 3.23736e6 * np.power(1.0 + n, 3) - + 1.797035e6 * np.power(1.0 + n, 4) - + 671790.0 * np.power(1.0 + n, 5) - + 171248.0 * np.power(1.0 + n, 6) - + 29400.0 * np.power(1.0 + n, 7) - + 3255.0 * np.power(1.0 + n, 8) - + 210.0 * np.power(1.0 + n, 9) - + 6.0 * np.power(1.0 + n, 10) + * (1 / (1.0 + n) + S1) + * np.power(-1.0, n) ) / ( np.power(2.0 + n, 2) @@ -4843,1683 +5273,1215 @@ def F12(n, S1, S2): * np.power(5.0 + n, 2) * np.power(6.0 + n, 2) * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + ( + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 + ) + * ( + Sm2 + - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) + * ( + 3.6831936e7 + + 1.10670624e8 * (1.0 + n) + + 1.4936364e8 * np.power(1.0 + n, 2) + + 1.2041208e8 * np.power(1.0 + n, 3) + + 6.4783246e7 * np.power(1.0 + n, 4) + + 2.454111e7 * np.power(1.0 + n, 5) + + 6.715739e6 * np.power(1.0 + n, 6) + + 1.33785e6 * np.power(1.0 + n, 7) + + 192561.0 * np.power(1.0 + n, 8) + + 19530.0 * np.power(1.0 + n, 9) + + 1325.0 * np.power(1.0 + n, 10) + + 54.0 * np.power(1.0 + n, 11) + + np.power(1.0 + n, 12) + ) + * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) ) - + S2 ) ) - ) - / np.power(7.0 + n, 2) - + n - * ( - np.power(7.0 + n, -5) - - 1.2020569031595942 / np.power(7.0 + n, 2) - + 0.27058080842778454 / (7.0 + n) - + ( - 1 / (1.0 + n) - + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) - + S1 - ) - / np.power(7.0 + n, 4) - + ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 21076.0 - + 62100.0 * (1.0 + n) - + 79650.0 * np.power(1.0 + n, 2) - + 57660.0 * np.power(1.0 + n, 3) - + 25685.0 * np.power(1.0 + n, 4) - + 7200.0 * np.power(1.0 + n, 5) - + 1240.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 5.0 * np.power(1.0 + n, 8) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - ) - + S2 - ) - ) - / np.power(7.0 + n, 3) + / np.power(10.0 + n, 2) ) ) - + 0.056951717764149916 + ) + + +@nb.njit("c16(c16,c16,c16)", cache=True) +def F13(n, S1, S2): + return ( + -0.15312792746068732 * n + + (0.13621083778040208 * n) / (2.0 + n) + - (0.474631789932249 * n) / (3.0 + n) + + (0.24528438212633397 * n) / (4.0 + n) + - (0.26580874921126374 * n) / (5.0 + n) + + (1.2217722976683179 * n) / (6.0 + n) + - (3.6324293738026023 * n) / (7.0 + n) + + (7.4838836775956015 * n) / (8.0 + n) + - (10.706375063797914 * n) / (9.0 + n) + + (10.449787985527623 * n) / (10.0 + n) + - (6.649468393739114 * n) / (11.0 + n) + + (2.4904695902320904 * n) / (12.0 + n) + - (0.41762920477450316 * n) / (13.0 + n) + - 0.2720646169555415 * (-1.0 + 1 / (1.0 + n)) + - 0.0030864197530864196 + * n * ( - 1.2020569031595942 / (8.0 + n) + -49.613452021037574 + + 1695.6636939202713 / (1.0 + n) + + 297.65017554444273 / (2.0 + n) + - 53.043164791285136 / (3.0 + n) + + (280.1816714156928 * (1.0 + (1.0 + n) * S1)) / np.power(1.0 + n, 2) + + (566.2149227313704 * (1.0 + (2.0 + n) * (1 / (1.0 + n) + S1))) + / np.power(2.0 + n, 2) - ( - 1.0 + 115.5647471869277 + * (1.0 + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) + ) + / np.power(3.0 + n, 2) + - ( + 1607.5136662661575 * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + S1, - 2, - ) - + 0.5 + 1.0 + + n + * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) + ) + ) + / np.power(n, 2) + + ( + 972.0 + * ( + 1.0 + + (2.0 + n) * (1 / (1.0 + n) + S1) + + np.power(2.0 + n, 2) * ( np.power(1.0 + n, -2) - + ( - 3.8402064e7 - + 1.38523392e8 * (1.0 + n) - + 2.26358048e8 * np.power(1.0 + n, 2) - + 2.20651312e8 * np.power(1.0 + n, 3) - + 1.42622963e8 * np.power(1.0 + n, 4) - + 6.434848e7 * np.power(1.0 + n, 5) - + 2.07774e7 * np.power(1.0 + n, 6) - + 4.838848e6 * np.power(1.0 + n, 7) - + 807086.0 * np.power(1.0 + n, 8) - + 94080.0 * np.power(1.0 + n, 9) - + 7280.0 * np.power(1.0 + n, 10) - + 336.0 * np.power(1.0 + n, 11) - + 7.0 * np.power(1.0 + n, 12) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - ) - + S2 + + S1 / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) ) ) ) - / np.power(8.0 + n, 2) - + n - * ( - np.power(8.0 + n, -5) - - 1.2020569031595942 / np.power(8.0 + n, 2) - + 0.27058080842778454 / (8.0 + n) - + ( - 1 / (1.0 + n) - + ( - (7.0 + 2.0 * (1.0 + n)) - * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - ) - + S1 - ) - / np.power(8.0 + n, 4) - + ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - (7.0 + 2.0 * (1.0 + n)) - * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - ) - + S1, - 2, - ) - + 0.5 + / np.power(2.0 + n, 3) + - ( + 1296.0 + * ( + 1.0 + + (1.0 + n) * S1 + + np.power(1.0 + n, 2) * ( np.power(1.0 + n, -2) - + ( - 773136.0 - + 2.554272e6 * (1.0 + n) - + 3.762752e6 * np.power(1.0 + n, 2) - + 3.23736e6 * np.power(1.0 + n, 3) - + 1.797035e6 * np.power(1.0 + n, 4) - + 671790.0 * np.power(1.0 + n, 5) - + 171248.0 * np.power(1.0 + n, 6) - + 29400.0 * np.power(1.0 + n, 7) - + 3255.0 * np.power(1.0 + n, 8) - + 210.0 * np.power(1.0 + n, 9) - + 6.0 * np.power(1.0 + n, 10) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - ) - + S2 + + S1 / (1.0 + n) + - (1.0 * (1 / (1.0 + n) + S1)) / (1.0 + n) + + 0.5 * (np.power(S1, 2) + S2) ) ) - / np.power(8.0 + n, 3) ) - ) - - 0.019847559824380426 - * ( - 1.2020569031595942 / (9.0 + n) + / np.power(1.0 + n, 3) - ( - 1.0 + 216.0 * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1, - 2, - ) - + 0.5 + 1.0 + + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) + + np.power(3.0 + n, 2) * ( np.power(1.0 + n, -2) - + ( - 4.0 - * ( - 6.20783424e8 - + 2.402913888e9 * (1.0 + n) - + 4.261208648e9 * np.power(1.0 + n, 2) - + 4.5733464e9 * np.power(1.0 + n, 3) - + 3.31344237e9 * np.power(1.0 + n, 4) - + 1.713293694e9 * np.power(1.0 + n, 5) - + 6.51986769e8 * np.power(1.0 + n, 6) - + 1.85551632e8 * np.power(1.0 + n, 7) - + 3.9703709e7 * np.power(1.0 + n, 8) - + 6.360228e6 * np.power(1.0 + n, 9) - + 751317.0 * np.power(1.0 + n, 10) - + 63504.0 * np.power(1.0 + n, 11) - + 3633.0 * np.power(1.0 + n, 12) - + 126.0 * np.power(1.0 + n, 13) - + 2.0 * np.power(1.0 + n, 14) - ) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - ) - + S2 + + np.power(2.0 + n, -2) + + S1 / (1.0 + n) + + (1 / (1.0 + n) + S1) / (2.0 + n) + + 0.5 * (np.power(S1, 2) + S2) ) ) ) - / np.power(9.0 + n, 2) - + n - * ( - np.power(9.0 + n, -5) - - 1.2020569031595942 / np.power(9.0 + n, 2) - + 0.27058080842778454 / (9.0 + n) - + ( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + S1 - ) - / np.power(9.0 + n, 4) - + ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 3.8402064e7 - + 1.38523392e8 * (1.0 + n) - + 2.26358048e8 * np.power(1.0 + n, 2) - + 2.20651312e8 * np.power(1.0 + n, 3) - + 1.42622963e8 * np.power(1.0 + n, 4) - + 6.434848e7 * np.power(1.0 + n, 5) - + 2.07774e7 * np.power(1.0 + n, 6) - + 4.838848e6 * np.power(1.0 + n, 7) - + 807086.0 * np.power(1.0 + n, 8) - + 94080.0 * np.power(1.0 + n, 9) - + 7280.0 * np.power(1.0 + n, 10) - + 336.0 * np.power(1.0 + n, 11) - + 7.0 * np.power(1.0 + n, 12) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - ) - + S2 - ) - ) - / np.power(9.0 + n, 3) - ) - ) - + 0.003243204652309423 - * ( - 1.2020569031595942 / (10.0 + n) - - ( - 1.0 + / np.power(3.0 + n, 3) + + ( + 540.0 * ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 3.0 - * ( - 342192.0 - + 781800.0 * (1.0 + n) - + 723680.0 * np.power(1.0 + n, 2) - + 359100.0 * np.power(1.0 + n, 3) - + 105455.0 * np.power(1.0 + n, 4) - + 18900.0 * np.power(1.0 + n, 5) - + 2030.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 3.0 * np.power(1.0 + n, 8) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - ) - + S1, - 2, - ) - + 0.5 - * ( - np.power(1.0 + n, -2) - + ( - 3.0 - * ( - 6.7586510592e10 - + 2.7735912e11 * (1.0 + n) - + 5.25886236e11 * np.power(1.0 + n, 2) - + 6.098325648e11 * np.power(1.0 + n, 3) - + 4.8346372324e11 * np.power(1.0 + n, 4) - + 2.77716663e11 * np.power(1.0 + n, 5) - + 1.195744907e11 * np.power(1.0 + n, 6) - + 3.937668588e10 * np.power(1.0 + n, 7) - + 1.0027662147e10 * np.power(1.0 + n, 8) - + 1.982481e9 * np.power(1.0 + n, 9) - + 3.0344942e8 * np.power(1.0 + n, 10) - + 3.560508e7 * np.power(1.0 + n, 11) - + 3.141418e6 * np.power(1.0 + n, 12) - + 201600.0 * np.power(1.0 + n, 13) - + 8880.0 * np.power(1.0 + n, 14) - + 240.0 * np.power(1.0 + n, 15) - + 3.0 * np.power(1.0 + n, 16) - ) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - * np.power(10.0 + n, 2) - ) - + S2 - ) - ) - ) - / np.power(10.0 + n, 2) - + n - * ( - np.power(10.0 + n, -5) - - 1.2020569031595942 / np.power(10.0 + n, 2) - + 0.27058080842778454 / (10.0 + n) - + ( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1 - ) - / np.power(10.0 + n, 4) - + ( - 0.5 - * np.power( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1, - 2, - ) - + 0.5 + 1.0 + + n + * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) + + np.power(n, 2) * ( np.power(1.0 + n, -2) - + ( - 4.0 - * ( - 6.20783424e8 - + 2.402913888e9 * (1.0 + n) - + 4.261208648e9 * np.power(1.0 + n, 2) - + 4.5733464e9 * np.power(1.0 + n, 3) - + 3.31344237e9 * np.power(1.0 + n, 4) - + 1.713293694e9 * np.power(1.0 + n, 5) - + 6.51986769e8 * np.power(1.0 + n, 6) - + 1.85551632e8 * np.power(1.0 + n, 7) - + 3.9703709e7 * np.power(1.0 + n, 8) - + 6.360228e6 * np.power(1.0 + n, 9) - + 751317.0 * np.power(1.0 + n, 10) - + 63504.0 * np.power(1.0 + n, 11) - + 3633.0 * np.power(1.0 + n, 12) - + 126.0 * np.power(1.0 + n, 13) - + 2.0 * np.power(1.0 + n, 14) - ) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - ) - + S2 + + 1 / (n * (1.0 + n)) + + S1 / (1.0 + n) + + ((1.0 - 2.0 * (1.0 + n)) * (1 / (1.0 + n) + S1)) + / (n * (1.0 + n)) + + 0.5 * (np.power(S1, 2) + S2) ) ) - / np.power(10.0 + n, 3) ) + / np.power(n, 3) ) ) -@nb.njit("c16(c16,c16)", cache=True) -def F9(n, S1): +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def F19(n, S1, S2, S3): return ( - 0.06236473052300693 * n - + (0.2690947900632558 * n) / (2.0 + n) - - (0.12825410062391376 * n) / (3.0 + n) - + (0.007553694508943639 * n) / (4.0 + n) - + (0.030446610389993342 * n) / (5.0 + n) - - (0.11774020607944516 * n) / (6.0 + n) - + (0.33716180147388786 * n) / (7.0 + n) - - (0.6676623948212598 * n) / (8.0 + n) - + (0.9225597682535133 * n) / (9.0 + n) - - (0.8726283036193748 * n) / (10.0 + n) - + (0.5398117849858193 * n) / (11.0 + n) - - (0.1970839223372511 * n) / (12.0 + n) - + (0.03230590731253853 * n) / (13.0 + n) - + 0.21793029342350395 * (-1.0 + 1 / (1.0 + n)) - - 0.000925925925925926 - * n - * ( - 67.35391078053772 - + 993.5438760599122 / (1.0 + n) - + 185.10074515651877 / (2.0 + n) - - 21.841303653529422 / (3.0 + n) - + (180.0 * (1.0 + (1.0 + n) * S1)) / np.power(1.0 + n, 2) - - (180.0 * (1.0 + (2.0 + n) * (1 / (1.0 + n) + S1))) / np.power(2.0 + n, 2) - + (60.0 * (1.0 + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1))) - / np.power(3.0 + n, 2) - - ( - 1228.9090924080292 - * ( - 1.0 - + n - * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) - ) - ) - / np.power(n, 2) - ) - ) - + 7.548974594558902 + - 1.5497677311665408 / np.power(1.0 + n, 3) + - 0.5497677311665407 / np.power(2.0 + n, 3) + + 2.0 / np.power(2.0 + n, 2) + - 11.975319856741933 / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - (14.370383828090318 * n) / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - (4.790127942696773 * np.power(n, 2)) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + 3.0 / (2.0 + n) + - 9.738329251443808 / ((1.0 + n) * (2.0 + n)) + - (6.492219500962539 * n) / ((1.0 + n) * (2.0 + n)) + - 0.2997677311665407 / np.power(3.0 + n, 3) + - 0.1450639713483865 / np.power(3.0 + n, 2) + - 0.05860975048126964 / (3.0 + n) + - 0.18865662005542957 / np.power(4.0 + n, 3) + - 0.07098989727431243 / np.power(4.0 + n, 2) + - 0.021572713444232602 / (4.0 + n) + - 0.12615662005542957 / np.power(5.0 + n, 3) + - 0.03973989727431243 / np.power(5.0 + n, 2) + - 0.009853963444232604 / (5.0 + n) + - 0.08615662005542958 / np.power(6.0 + n, 3) + - 0.02373989727431243 / np.power(6.0 + n, 2) + - 0.005053963444232604 / (6.0 + n) + - 0.058378842277651805 / np.power(7.0 + n, 3) + - 0.01448063801505317 / np.power(7.0 + n, 2) + - 0.0027391486294177886 / (7.0 + n) + - 0.03797067901234568 / np.power(8.0 + n, 3) + - 0.008649734224965707 / np.power(8.0 + n, 2) + - 0.0014896692458276177 / (8.0 + n) + - 0.02234567901234568 / np.power(9.0 + n, 3) + - 0.004743484224965707 / np.power(9.0 + n, 2) + - 0.0007572473708276177 / (9.0 + n) + - 0.01 / np.power(10.0 + n, 3) + - 0.002 / np.power(10.0 + n, 2) + - 0.0003 / (10.0 + n) + - 3.2461097504812697 * S1 + - 2.3950639713483866 * S2 + - (1.5497677311665408 * S3) / np.power(1.0 + n, 3) + - (4.649303193499622 * n * S3) / np.power(1.0 + n, 3) + - (4.649303193499622 * np.power(n, 2) * S3) / np.power(1.0 + n, 3) + - (1.5497677311665408 * np.power(n, 3) * S3) / np.power(1.0 + n, 3) + ) -@nb.njit("c16(c16,c16,c16,c16,c16,c16)", cache=True) -def F16(n, S1, Sm1, Sm2, Sm3, Sm21): + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def F21(n, Sm1, Sm2, Sm3): + return 2.3148148148148148e-7 * ( + 2.383072892806571e7 / np.power(-1.0, 1.0 * n) + + 970000.0 / (2.0 + n) + - 922800.0 / np.power(3.0 + n, 3) + - 524120.0 / np.power(3.0 + n, 2) + - 210625.0 / (3.0 + n) + - 1.56e6 / np.power(4.0 + n, 3) + + 1.1232e8 / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + + (9.36e7 * n) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + + (2.808e7 * np.power(n, 2)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + + (3.12e6 * np.power(n, 3)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + - 1.4e6 / np.power(4.0 + n, 2) + + 2.8e7 / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + + (1.68e7 * n) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + + (2.8e6 * np.power(n, 2)) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + - 172800.0 / np.power(5.0 + n, 3) + - 69120.0 / np.power(5.0 + n, 2) + - 442800.0 / np.power(6.0 + n, 3) + + 7.1131392e9 + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (9.6920064e9 * n) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (5.632416e9 * np.power(n, 2)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (1.7853696e9 * np.power(n, 3)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (3.241296e8 * np.power(n, 4)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (3.18816e7 * np.power(n, 5)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + (1.3284e6 * np.power(n, 6)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - 204120.0 / np.power(6.0 + n, 2) + + 1.6003008e8 + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + + (1.5676416e8 * n) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + + (5.878656e7 * np.power(n, 2)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + + (9.79776e6 * np.power(n, 3)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + + (612360.0 * np.power(n, 4)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + + 428166.0 / (8.0 + 6.0 * n + np.power(n, 2)) + + (142722.0 * n) / (8.0 + 6.0 * n + np.power(n, 2)) + - 165888.0 / (15.0 + 8.0 * n + np.power(n, 2)) + - (41472.0 * n) / (15.0 + 8.0 * n + np.power(n, 2)) + + (1.4001361e7 * Sm1) / np.power(-1.0, 1.0 * n) + + (1.024412e7 * Sm2) / np.power(-1.0, 1.0 * n) + + (6.3228e6 * Sm3) / np.power(-1.0, 1.0 * n) + + ( + np.power(-1.0, 1.0 - 1.0 * n) + * (3.0568281e7 + 3.8246842e7 * n + 1.4001361e7 * np.power(n, 2)) + * np.power(-1.0, n) + ) + / np.power(1.0 + n, 3) + ) + + +@nb.njit("c16(c16,c16,c16,c16)", cache=True) +def F20(n, Sm1, Sm2, Sm3): + return 2.3148148148148148e-7 * ( + 1.8204889223408133e7 / np.power(-1.0, 1.0 * n) + - 650000.0 / (2.0 + n) + - 382800.0 / np.power(3.0 + n, 3) + - 254120.0 / np.power(3.0 + n, 2) + - 109375.0 / (3.0 + n) + + 600000.0 / np.power(4.0 + n, 3) + - 4.32e7 / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + - (3.6e7 * n) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + - (1.08e7 * np.power(n, 2)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + - (1.2e6 * np.power(n, 3)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) + + 760000.0 / np.power(4.0 + n, 2) + - 1.52e7 / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + - (9.12e6 * n) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + - (1.52e6 * np.power(n, 2)) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) + - 172800.0 / np.power(5.0 + n, 3) + - 69120.0 / np.power(5.0 + n, 2) + + 97200.0 / np.power(6.0 + n, 3) + - 1.5614208e9 + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (2.1275136e9 * n) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (1.236384e9 * np.power(n, 2)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (3.919104e8 * np.power(n, 3)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (7.11504e7 * np.power(n, 4)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (6.9984e6 * np.power(n, 5)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + - (291600.0 * np.power(n, 6)) + / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) + + 65880.0 / np.power(6.0 + n, 2) + - 5.164992e7 + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + - (5.059584e7 * n) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + - (1.897344e7 * np.power(n, 2)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + - (3.16224e6 * np.power(n, 3)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + - (197640.0 * np.power(n, 4)) + / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) + - 179334.0 / (8.0 + 6.0 * n + np.power(n, 2)) + - (59778.0 * n) / (8.0 + 6.0 * n + np.power(n, 2)) + - 165888.0 / (15.0 + 8.0 * n + np.power(n, 2)) + - (41472.0 * n) / (15.0 + 8.0 * n + np.power(n, 2)) + + (1.2280111e7 * Sm1) / np.power(-1.0, 1.0 * n) + + (7.81412e6 * Sm2) / np.power(-1.0, 1.0 * n) + + (3.6228e6 * Sm3) / np.power(-1.0, 1.0 * n) + + ( + np.power(-1.0, 1.0 - 1.0 * n) + * (2.3717031e7 + 3.2374342e7 * n + 1.2280111e7 * np.power(n, 2)) + * np.power(-1.0, n) + ) + / np.power(1.0 + n, 3) + ) + + +@nb.njit("c16(c16,c16,c16)", cache=True) +def F14F12(n, S1, S21): return ( - -0.23444040559418688 - - 0.9999999952263307 + -0.5626569734260486 + + 0.49999902059348167 * ( - -0.419833592426477 / (1.0 + n) - - (0.18119485915332012 * np.power(-1.0, 1.0 + n)) / (1.0 + n) - - (0.6010284515797971 * np.power(-1.0, 2.0 + n)) / (1.0 + n) - - (0.8224670334241131 * np.power(-1.0, 1.0 + n) * (1 / (1.0 + n) + S1)) - / (1.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 2.0 + n) - * (Sm1 - (1.0 * np.power(-1.0, n)) / (1.0 + n)) - ) - / (1.0 + n) + (-1.6449340668482262 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / (2.0 + n) + ( - np.power(-1.0, 2.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + (1 / (1.0 + n) + S1) - * (Sm2 - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2)) - ) + np.power(1.0 + n, -3) + + np.power(2.0 + n, -3) + + S1 / np.power(1.0 + n, 2) + + (1 / (1.0 + n) + S1) / np.power(2.0 + n, 2) + + S21 ) - / (1.0 + n) + / (2.0 + n) + n * ( - np.power(1.0 + n, -5) - - 0.8224670334241131 / np.power(1.0 + n, 3) - - (0.8224670334241131 * np.power(-1.0, n)) / np.power(1.0 + n, 3) - + 0.419833592426477 / np.power(1.0 + n, 2) - + (1.6218904955860713 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + (1.2020569031595942 * np.power(-1.0, 1.0 + n)) / np.power(1.0 + n, 2) - - 0.3382260105347306 / (1.0 + n) - - (0.8224670334241131 * np.power(-1.0, n) * S1) / np.power(1.0 + n, 2) - - (0.8224670334241131 * np.power(-1.0, 1.0 + n) * Sm1) - / np.power(1.0 + n, 2) - + (np.power(-1.0, 1.0 + n) * Sm2) / np.power(1.0 + n, 3) - + ( - np.power(-1.0, 1.0 + n) + -1.0 / np.power(2.0 + n, 5) + + 1.6449340668482262 / np.power(2.0 + n, 3) + - 0.8117424252833533 / (2.0 + n) + - (1.0 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 4) + + (1.6449340668482262 * (1 / (1.0 + n) + S1)) / np.power(2.0 + n, 2) + - (1.0 * (np.power(1.0 + n, -3) + S1 / np.power(1.0 + n, 2) + S21)) + / np.power(2.0 + n, 2) + ) + ) + - 0.9999999952263307 + * ( + (-1.6449340668482262 * (1 / (1.0 + n) + S1)) / (1.0 + n) + + (np.power(1.0 + n, -3) + S1 / np.power(1.0 + n, 2) + S21) / (1.0 + n) + + n + * ( + -1.0 / np.power(1.0 + n, 5) + + 1.6449340668482262 / np.power(1.0 + n, 3) + - 0.8117424252833533 / (1.0 + n) + - (1.0 * S1) / np.power(1.0 + n, 4) + + (1.6449340668482262 * S1) / np.power(1.0 + n, 2) + - ( + 1.0 * ( - S1 * Sm2 - - 1.0 * Sm21 - + Sm3 - + np.power(-1.0, n) / np.power(1.0 + n, 3) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - (1.0 * (1 / (1.0 + n) + S1) * np.power(-1.0, n)) - / np.power(1.0 + n, 2) + np.power(1.0 + n, -3) + + S1 / np.power(1.0 + n, 2) + - (1.0 * (1 / (1.0 + n) + S1)) / np.power(1.0 + n, 2) + + S21 ) ) / np.power(1.0 + n, 2) ) ) - + 0.49999902059348167 + - 0.3332995604546604 * ( - -0.419833592426477 / (2.0 + n) - - (0.18119485915332012 * np.power(-1.0, 2.0 + n)) / (2.0 + n) - - (0.6010284515797971 * np.power(-1.0, 3.0 + n)) / (2.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 2.0 + n) - * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) - ) - / (2.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 3.0 + n) + ( + -1.6449340668482262 * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - + np.power(-1.0, n) / (2.0 + n) + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 ) ) - / (2.0 + n) + / (3.0 + n) + ( - np.power(-1.0, 3.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - (1.0 * (1 / (1.0 + n) + S1) * np.power(-1.0, n)) - / np.power(2.0 + n, 2) - + (1 / (1.0 + n) + 1 / (2.0 + n) + S1) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + np.power(-1.0, n) / np.power(2.0 + n, 2) - ) + np.power(1.0 + n, -3) + + ( + 11.0 + + 20.0 * (1.0 + n) + + 13.0 * np.power(1.0 + n, 2) + + 3.0 * np.power(1.0 + n, 3) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + S1 / np.power(1.0 + n, 2) + + ( + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + * (1 / (1.0 + n) + S1) ) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S21 ) - / (2.0 + n) + / (3.0 + n) + n * ( - np.power(2.0 + n, -5) - - 0.8224670334241131 / np.power(2.0 + n, 3) - - (0.8224670334241131 * np.power(-1.0, 1.0 + n)) / np.power(2.0 + n, 3) - + 0.419833592426477 / np.power(2.0 + n, 2) - + (1.6218904955860713 * np.power(-1.0, 1.0 + n)) / np.power(2.0 + n, 2) - + (1.2020569031595942 * np.power(-1.0, 2.0 + n)) / np.power(2.0 + n, 2) - - 0.3382260105347306 / (2.0 + n) - - (0.8224670334241131 * np.power(-1.0, 1.0 + n) * (1 / (1.0 + n) + S1)) - / np.power(2.0 + n, 2) - + ( - np.power(-1.0, 2.0 + n) - * (Sm2 - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2)) - ) - / np.power(2.0 + n, 3) + -1.0 / np.power(3.0 + n, 5) + + 1.6449340668482262 / np.power(3.0 + n, 3) + - 0.8117424252833533 / (3.0 + n) + - (1.0 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / np.power(3.0 + n, 4) + + (1.6449340668482262 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) + / np.power(3.0 + n, 2) - ( - 0.8224670334241131 - * np.power(-1.0, 2.0 + n) - * (Sm1 - (1.0 * np.power(-1.0, n)) / (1.0 + n)) - ) - / np.power(2.0 + n, 2) - + ( - np.power(-1.0, 2.0 + n) + 1.0 * ( - -1.0 * Sm21 - + Sm3 - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + (1 / (1.0 + n) + S1) - * (Sm2 - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2)) + np.power(1.0 + n, -3) + + np.power(2.0 + n, -3) + + S1 / np.power(1.0 + n, 2) + + (1 / (1.0 + n) + S1) / np.power(2.0 + n, 2) + + S21 ) ) - / np.power(2.0 + n, 2) + / np.power(3.0 + n, 2) ) ) - - 0.3332995604546604 + + 0.24954082848379078 * ( - -0.419833592426477 / (3.0 + n) - - (0.18119485915332012 * np.power(-1.0, 3.0 + n)) / (3.0 + n) - - (0.6010284515797971 * np.power(-1.0, 4.0 + n)) / (3.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 3.0 + n) + ( + -1.6449340668482262 * ( 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + S1 ) ) - / (3.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 4.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - + np.power(-1.0, n) / ((2.0 + n) * (3.0 + n)) - ) - ) - / (3.0 + n) + / (4.0 + n) + ( - np.power(-1.0, 4.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - - ( - 1.0 - * (-7.0 - 9.0 * (1.0 + n) - 3.0 * np.power(1.0 + n, 2)) - * np.power(-1.0, n) - ) - / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) - + ( - ( - -5.0 - - 4.0 * (1.0 + n) - + np.power(1.0 + n, 2) - + np.power(1.0 + n, 3) - ) - * np.power(-1.0, n) - ) - / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - (-3.0 - 2.0 * (1.0 + n)) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) - ) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) - + ( - 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) - + S1 - ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - (1.0 * (-3.0 - 2.0 * (1.0 + n)) * np.power(-1.0, n)) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + np.power(1.0 + n, -3) + + ( + 341.0 + + 1017.0 * (1.0 + n) + + 1289.0 * np.power(1.0 + n, 2) + + 881.0 * np.power(1.0 + n, 3) + + 340.0 * np.power(1.0 + n, 4) + + 70.0 * np.power(1.0 + n, 5) + + 6.0 * np.power(1.0 + n, 6) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3) * np.power(4.0 + n, 3)) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) ) + * (1 / (1.0 + n) + S1) ) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2) * np.power(4.0 + n, 2)) + + S21 ) - / (3.0 + n) + / (4.0 + n) + n * ( - np.power(3.0 + n, -5) - - 0.8224670334241131 / np.power(3.0 + n, 3) - - (0.8224670334241131 * np.power(-1.0, 2.0 + n)) / np.power(3.0 + n, 3) - + 0.419833592426477 / np.power(3.0 + n, 2) - + (1.6218904955860713 * np.power(-1.0, 2.0 + n)) / np.power(3.0 + n, 2) - + (1.2020569031595942 * np.power(-1.0, 3.0 + n)) / np.power(3.0 + n, 2) - - 0.3382260105347306 / (3.0 + n) + -1.0 / np.power(4.0 + n, 5) + + 1.6449340668482262 / np.power(4.0 + n, 3) + - 0.8117424252833533 / (4.0 + n) - ( - 0.8224670334241131 - * np.power(-1.0, 2.0 + n) - * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) - ) - / np.power(3.0 + n, 2) - + ( - np.power(-1.0, 3.0 + n) + 1.0 * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + np.power(-1.0, n) / np.power(2.0 + n, 2) + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 ) ) - / np.power(3.0 + n, 3) - - ( - 0.8224670334241131 - * np.power(-1.0, 3.0 + n) + / np.power(4.0 + n, 4) + + ( + 1.6449340668482262 * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - + np.power(-1.0, n) / (2.0 + n) + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 ) ) - / np.power(3.0 + n, 2) - + ( - np.power(-1.0, 3.0 + n) + / np.power(4.0 + n, 2) + - ( + 1.0 * ( - -1.0 * Sm21 - + Sm3 - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - (1.0 * (1 / (1.0 + n) + S1) * np.power(-1.0, n)) - / np.power(2.0 + n, 2) - + (1 / (1.0 + n) + 1 / (2.0 + n) + S1) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + np.power(-1.0, n) / np.power(2.0 + n, 2) + np.power(1.0 + n, -3) + + ( + 11.0 + + 20.0 * (1.0 + n) + + 13.0 * np.power(1.0 + n, 2) + + 3.0 * np.power(1.0 + n, 3) + ) + / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + S1 / np.power(1.0 + n, 2) + + ( + (5.0 + 6.0 * (1.0 + n) + 2.0 * np.power(1.0 + n, 2)) + * (1 / (1.0 + n) + S1) ) + / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S21 ) ) - / np.power(3.0 + n, 2) + / np.power(4.0 + n, 2) ) ) - + 0.24954082848379078 + - 0.1967571967137462 * ( - -0.419833592426477 / (4.0 + n) - - (0.18119485915332012 * np.power(-1.0, 4.0 + n)) / (4.0 + n) - - (0.6010284515797971 * np.power(-1.0, 5.0 + n)) / (4.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 4.0 + n) + ( + -1.6449340668482262 * ( 1 / (1.0 + n) - + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + S1 ) ) - / (4.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 5.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - - ( - 1.0 - * (-5.0 - 4.0 * (1.0 + n) - 1.0 * np.power(1.0 + n, 2)) - * np.power(-1.0, n) + / (5.0 + n) + + ( + np.power(1.0 + n, -3) + + ( + 23624.0 + + 90576.0 * (1.0 + n) + + 155374.0 * np.power(1.0 + n, 2) + + 155615.0 * np.power(1.0 + n, 3) + + 99831.0 * np.power(1.0 + n, 4) + + 42413.0 * np.power(1.0 + n, 5) + + 11911.0 * np.power(1.0 + n, 6) + + 2130.0 * np.power(1.0 + n, 7) + + 220.0 * np.power(1.0 + n, 8) + + 10.0 * np.power(1.0 + n, 9) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + * (1 / (1.0 + n) + S1) ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + S21 ) - / (4.0 + n) - + ( - np.power(-1.0, 5.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - + ( - ( - -179.0 - - 423.0 * (1.0 + n) - - 425.0 * np.power(1.0 + n, 2) - - 245.0 * np.power(1.0 + n, 3) - - 90.0 * np.power(1.0 + n, 4) - - 20.0 * np.power(1.0 + n, 5) - - 2.0 * np.power(1.0 + n, 6) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) + / (5.0 + n) + + n + * ( + -1.0 / np.power(5.0 + n, 5) + + 1.6449340668482262 / np.power(5.0 + n, 3) + - 0.8117424252833533 / (5.0 + n) + - ( + 1.0 + * ( + 1 / (1.0 + n) + + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 ) - - ( - 1.0 - * ( - -197.0 - - 468.0 * (1.0 + n) - - 453.0 * np.power(1.0 + n, 2) - - 232.0 * np.power(1.0 + n, 3) - - 69.0 * np.power(1.0 + n, 4) - - 12.0 * np.power(1.0 + n, 5) - - 1.0 * np.power(1.0 + n, 6) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - ( - -31.0 - - 48.0 * (1.0 + n) - - 28.0 * np.power(1.0 + n, 2) - - 8.0 * np.power(1.0 + n, 3) - - 1.0 * np.power(1.0 + n, 4) - ) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - ) - + ( + ) + / np.power(5.0 + n, 4) + + ( + 1.6449340668482262 + * ( 1 / (1.0 + n) + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + S1 ) + ) + / np.power(5.0 + n, 2) + - ( + 1.0 * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 1.0 - * ( - -31.0 - - 48.0 * (1.0 + n) - - 28.0 * np.power(1.0 + n, 2) - - 8.0 * np.power(1.0 + n, 3) - - 1.0 * np.power(1.0 + n, 4) + np.power(1.0 + n, -3) + + ( + 341.0 + + 1017.0 * (1.0 + n) + + 1289.0 * np.power(1.0 + n, 2) + + 881.0 * np.power(1.0 + n, 3) + + 340.0 * np.power(1.0 + n, 4) + + 70.0 * np.power(1.0 + n, 5) + + 6.0 * np.power(1.0 + n, 6) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 49.0 + + 96.0 * (1.0 + n) + + 72.0 * np.power(1.0 + n, 2) + + 24.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) ) - * np.power(-1.0, n) + * (1 / (1.0 + n) + S1) ) / ( np.power(2.0 + n, 2) * np.power(3.0 + n, 2) * np.power(4.0 + n, 2) ) + + S21 ) ) + / np.power(5.0 + n, 2) ) - / (4.0 + n) + ) + + 0.1530503487172192 + * ( + ( + -1.6449340668482262 + * ( + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 + ) + ) + / (6.0 + n) + + ( + np.power(1.0 + n, -3) + + ( + 3.110824e6 + + 1.40106e7 * (1.0 + n) + + 2.894151e7 * np.power(1.0 + n, 2) + + 3.6105269e7 * np.power(1.0 + n, 3) + + 3.0197768e7 * np.power(1.0 + n, 4) + + 1.7798299e7 * np.power(1.0 + n, 5) + + 7.568825e6 * np.power(1.0 + n, 6) + + 2.337861e6 * np.power(1.0 + n, 7) + + 520317.0 * np.power(1.0 + n, 8) + + 81361.0 * np.power(1.0 + n, 9) + + 8485.0 * np.power(1.0 + n, 10) + + 530.0 * np.power(1.0 + n, 11) + + 15.0 * np.power(1.0 + n, 12) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + S21 + ) + / (6.0 + n) + n * ( - np.power(4.0 + n, -5) - - 0.8224670334241131 / np.power(4.0 + n, 3) - - (0.8224670334241131 * np.power(-1.0, 3.0 + n)) / np.power(4.0 + n, 3) - + 0.419833592426477 / np.power(4.0 + n, 2) - + (1.6218904955860713 * np.power(-1.0, 3.0 + n)) / np.power(4.0 + n, 2) - + (1.2020569031595942 * np.power(-1.0, 4.0 + n)) / np.power(4.0 + n, 2) - - 0.3382260105347306 / (4.0 + n) + -1.0 / np.power(6.0 + n, 5) + + 1.6449340668482262 / np.power(6.0 + n, 3) + - 0.8117424252833533 / (6.0 + n) - ( - 0.8224670334241131 - * np.power(-1.0, 3.0 + n) + 1.0 * ( 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + S1 ) ) - / np.power(4.0 + n, 2) - - ( - 0.8224670334241131 - * np.power(-1.0, 4.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - + np.power(-1.0, n) / ((2.0 + n) * (3.0 + n)) - ) - ) - / np.power(4.0 + n, 2) + / np.power(6.0 + n, 4) + ( - np.power(-1.0, 4.0 + n) + 1.6449340668482262 * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - (1.0 * (-3.0 - 2.0 * (1.0 + n)) * np.power(-1.0, n)) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + 1 / (1.0 + n) + + ( + 2.0 + * (5.0 + 2.0 * (1.0 + n)) + * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 ) ) - / np.power(4.0 + n, 3) - + ( - np.power(-1.0, 4.0 + n) + / np.power(6.0 + n, 2) + - ( + 1.0 * ( - -1.0 * Sm21 - + Sm3 - - ( - 1.0 - * (-7.0 - 9.0 * (1.0 + n) - 3.0 * np.power(1.0 + n, 2)) - * np.power(-1.0, n) - ) - / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + np.power(1.0 + n, -3) + ( - ( - -5.0 - - 4.0 * (1.0 + n) - + np.power(1.0 + n, 2) - + np.power(1.0 + n, 3) - ) - * np.power(-1.0, n) + 23624.0 + + 90576.0 * (1.0 + n) + + 155374.0 * np.power(1.0 + n, 2) + + 155615.0 * np.power(1.0 + n, 3) + + 99831.0 * np.power(1.0 + n, 4) + + 42413.0 * np.power(1.0 + n, 5) + + 11911.0 * np.power(1.0 + n, 6) + + 2130.0 * np.power(1.0 + n, 7) + + 220.0 * np.power(1.0 + n, 8) + + 10.0 * np.power(1.0 + n, 9) ) - / (np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - (-3.0 - 2.0 * (1.0 + n)) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) ) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + + S1 / np.power(1.0 + n, 2) + ( - 1 / (1.0 + n) - + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) - + S1 + 2.0 + * ( + 410.0 + + 1030.0 * (1.0 + n) + + 1081.0 * np.power(1.0 + n, 2) + + 600.0 * np.power(1.0 + n, 3) + + 185.0 * np.power(1.0 + n, 4) + + 30.0 * np.power(1.0 + n, 5) + + 2.0 * np.power(1.0 + n, 6) + ) + * (1 / (1.0 + n) + S1) ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - (1.0 * (-3.0 - 2.0 * (1.0 + n)) * np.power(-1.0, n)) - / (np.power(2.0 + n, 2) * np.power(3.0 + n, 2)) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) ) + + S21 ) ) - / np.power(4.0 + n, 2) + / np.power(6.0 + n, 2) ) ) - - 0.1967571967137462 + - 0.10602798528818422 * ( - -0.419833592426477 / (5.0 + n) - - (0.18119485915332012 * np.power(-1.0, 5.0 + n)) / (5.0 + n) - - (0.6010284515797971 * np.power(-1.0, 6.0 + n)) / (5.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 5.0 + n) + ( + -1.6449340668482262 * ( 1 / (1.0 + n) + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1 - ) - ) - / (5.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 6.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - + ( - 2.0 - * (7.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) - * np.power(-1.0, n) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 ) ) - / (5.0 + n) + / (7.0 + n) + ( - np.power(-1.0, 6.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - + ( - 2.0 - * ( - 6196.0 - + 19110.0 * (1.0 + n) - + 25497.0 * np.power(1.0 + n, 2) - + 19295.0 * np.power(1.0 + n, 3) - + 9117.0 * np.power(1.0 + n, 4) - + 2775.0 * np.power(1.0 + n, 5) - + 535.0 * np.power(1.0 + n, 6) - + 60.0 * np.power(1.0 + n, 7) - + 3.0 * np.power(1.0 + n, 8) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - ) - + ( - ( - -9656.0 - - 26544.0 * (1.0 + n) - - 29682.0 * np.power(1.0 + n, 2) - - 16521.0 * np.power(1.0 + n, 3) - - 3745.0 * np.power(1.0 + n, 4) - + 787.0 * np.power(1.0 + n, 5) - + 793.0 * np.power(1.0 + n, 6) - + 236.0 * np.power(1.0 + n, 7) - + 34.0 * np.power(1.0 + n, 8) - + 2.0 * np.power(1.0 + n, 9) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * ( - 46.0 - + 70.0 * (1.0 + n) - + 39.0 * np.power(1.0 + n, 2) - + 10.0 * np.power(1.0 + n, 3) - + np.power(1.0 + n, 4) - ) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - ) - + ( - 1 / (1.0 + n) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1 - ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * ( - 46.0 - + 70.0 * (1.0 + n) - + 39.0 * np.power(1.0 + n, 2) - + 10.0 * np.power(1.0 + n, 3) - + np.power(1.0 + n, 4) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - ) + np.power(1.0 + n, -3) + + ( + 6.97339584e8 + + 3.525030432e9 * (1.0 + n) + + 8.293536336e9 * np.power(1.0 + n, 2) + + 1.2007529256e10 * np.power(1.0 + n, 3) + + 1.193375892e10 * np.power(1.0 + n, 4) + + 8.60864186e9 * np.power(1.0 + n, 5) + + 4.650892802e9 * np.power(1.0 + n, 6) + + 1.914862936e9 * np.power(1.0 + n, 7) + + 6.05522329e8 * np.power(1.0 + n, 8) + + 1.47044895e8 * np.power(1.0 + n, 9) + + 2.7198669e7 * np.power(1.0 + n, 10) + + 3.763711e6 * np.power(1.0 + n, 11) + + 377251.0 * np.power(1.0 + n, 12) + + 25865.0 * np.power(1.0 + n, 13) + + 1085.0 * np.power(1.0 + n, 14) + + 21.0 * np.power(1.0 + n, 15) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) ) + * (1 / (1.0 + n) + S1) ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + ) + + S21 ) - / (5.0 + n) + / (7.0 + n) + n * ( - np.power(5.0 + n, -5) - - 0.8224670334241131 / np.power(5.0 + n, 3) - - (0.8224670334241131 * np.power(-1.0, 4.0 + n)) / np.power(5.0 + n, 3) - + 0.419833592426477 / np.power(5.0 + n, 2) - + (1.6218904955860713 * np.power(-1.0, 4.0 + n)) / np.power(5.0 + n, 2) - + (1.2020569031595942 * np.power(-1.0, 5.0 + n)) / np.power(5.0 + n, 2) - - 0.3382260105347306 / (5.0 + n) + -1.0 / np.power(7.0 + n, 5) + + 1.6449340668482262 / np.power(7.0 + n, 3) + - 0.8117424252833533 / (7.0 + n) - ( - 0.8224670334241131 - * np.power(-1.0, 4.0 + n) + 1.0 * ( 1 / (1.0 + n) - + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1 - ) - ) - / np.power(5.0 + n, 2) - - ( - 0.8224670334241131 - * np.power(-1.0, 5.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - - ( - 1.0 - * (-5.0 - 4.0 * (1.0 + n) - 1.0 * np.power(1.0 + n, 2)) - * np.power(-1.0, n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 ) ) - / np.power(5.0 + n, 2) + / np.power(7.0 + n, 4) + ( - np.power(-1.0, 5.0 + n) + 1.6449340668482262 * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 1.0 - * ( - -31.0 - - 48.0 * (1.0 + n) - - 28.0 * np.power(1.0 + n, 2) - - 8.0 * np.power(1.0 + n, 3) - - 1.0 * np.power(1.0 + n, 4) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) + 1 / (1.0 + n) + + ( + 274.0 + + 450.0 * (1.0 + n) + + 255.0 * np.power(1.0 + n, 2) + + 60.0 * np.power(1.0 + n, 3) + + 5.0 * np.power(1.0 + n, 4) ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + + S1 ) ) - / np.power(5.0 + n, 3) - + ( - np.power(-1.0, 5.0 + n) + / np.power(7.0 + n, 2) + - ( + 1.0 * ( - -1.0 * Sm21 - + Sm3 + np.power(1.0 + n, -3) + ( - ( - -179.0 - - 423.0 * (1.0 + n) - - 425.0 * np.power(1.0 + n, 2) - - 245.0 * np.power(1.0 + n, 3) - - 90.0 * np.power(1.0 + n, 4) - - 20.0 * np.power(1.0 + n, 5) - - 2.0 * np.power(1.0 + n, 6) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - ) - - ( - 1.0 - * ( - -197.0 - - 468.0 * (1.0 + n) - - 453.0 * np.power(1.0 + n, 2) - - 232.0 * np.power(1.0 + n, 3) - - 69.0 * np.power(1.0 + n, 4) - - 12.0 * np.power(1.0 + n, 5) - - 1.0 * np.power(1.0 + n, 6) - ) - * np.power(-1.0, n) + 3.110824e6 + + 1.40106e7 * (1.0 + n) + + 2.894151e7 * np.power(1.0 + n, 2) + + 3.6105269e7 * np.power(1.0 + n, 3) + + 3.0197768e7 * np.power(1.0 + n, 4) + + 1.7798299e7 * np.power(1.0 + n, 5) + + 7.568825e6 * np.power(1.0 + n, 6) + + 2.337861e6 * np.power(1.0 + n, 7) + + 520317.0 * np.power(1.0 + n, 8) + + 81361.0 * np.power(1.0 + n, 9) + + 8485.0 * np.power(1.0 + n, 10) + + 530.0 * np.power(1.0 + n, 11) + + 15.0 * np.power(1.0 + n, 12) ) / ( np.power(2.0 + n, 3) * np.power(3.0 + n, 3) * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + S1 / np.power(1.0 + n, 2) + ( ( - -31.0 - - 48.0 * (1.0 + n) - - 28.0 * np.power(1.0 + n, 2) - - 8.0 * np.power(1.0 + n, 3) - - 1.0 * np.power(1.0 + n, 4) + 21076.0 + + 62100.0 * (1.0 + n) + + 79650.0 * np.power(1.0 + n, 2) + + 57660.0 * np.power(1.0 + n, 3) + + 25685.0 * np.power(1.0 + n, 4) + + 7200.0 * np.power(1.0 + n, 5) + + 1240.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 5.0 * np.power(1.0 + n, 8) ) * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) ) / ( np.power(2.0 + n, 2) * np.power(3.0 + n, 2) * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) ) - + ( - 1 / (1.0 + n) - + (11.0 + 12.0 * (1.0 + n) + 3.0 * np.power(1.0 + n, 2)) - / ((2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1 - ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 1.0 - * ( - -31.0 - - 48.0 * (1.0 + n) - - 28.0 * np.power(1.0 + n, 2) - - 8.0 * np.power(1.0 + n, 3) - - 1.0 * np.power(1.0 + n, 4) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - ) - ) + + S21 ) ) - / np.power(5.0 + n, 2) + / np.power(7.0 + n, 2) ) ) - + 0.1530503487172192 + + 0.056951717764149916 * ( - -0.419833592426477 / (6.0 + n) - - (0.18119485915332012 * np.power(-1.0, 6.0 + n)) / (6.0 + n) - - (0.6010284515797971 * np.power(-1.0, 7.0 + n)) / (6.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 6.0 + n) + ( + -1.6449340668482262 * ( 1 / (1.0 + n) + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + S1 ) ) - / (6.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 7.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - - ( - 1.0 - * ( - -94.0 - - 114.0 * (1.0 + n) - - 55.0 * np.power(1.0 + n, 2) - - 12.0 * np.power(1.0 + n, 3) - - 1.0 * np.power(1.0 + n, 4) - ) - * np.power(-1.0, n) + / (8.0 + n) + + ( + np.power(1.0 + n, -3) + + ( + 2.0 + * ( + 1.22980964256e11 + + 6.79202212752e11 * (1.0 + n) + + 1.762986212232e12 * np.power(1.0 + n, 2) + + 2.849976037428e12 * np.power(1.0 + n, 3) + + 3.208712317944e12 * np.power(1.0 + n, 4) + + 2.66793900071e12 * np.power(1.0 + n, 5) + + 1.696140569839e12 * np.power(1.0 + n, 6) + + 8.42534361945e11 * np.power(1.0 + n, 7) + + 3.31394293594e11 * np.power(1.0 + n, 8) + + 1.03973066426e11 * np.power(1.0 + n, 9) + + 2.6083138284e10 * np.power(1.0 + n, 10) + + 5.220244242e9 * np.power(1.0 + n, 11) + + 8.27501148e8 * np.power(1.0 + n, 12) + + 1.02512358e8 * np.power(1.0 + n, 13) + + 9.709175e6 * np.power(1.0 + n, 14) + + 678601.0 * np.power(1.0 + n, 15) + + 32970.0 * np.power(1.0 + n, 16) + + 994.0 * np.power(1.0 + n, 17) + + 14.0 * np.power(1.0 + n, 18) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + * (1 / (1.0 + n) + S1) ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S21 ) - / (6.0 + n) - + ( - np.power(-1.0, 7.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - + ( - ( - -1.364824e6 - - 4.959e6 * (1.0 + n) - - 8.21809e6 * np.power(1.0 + n, 2) - - 8.317171e6 * np.power(1.0 + n, 3) - - 5.805556e6 * np.power(1.0 + n, 4) - - 2.979747e6 * np.power(1.0 + n, 5) - - 1.160441e6 * np.power(1.0 + n, 6) - - 345225.0 * np.power(1.0 + n, 7) - - 77357.0 * np.power(1.0 + n, 8) - - 12617.0 * np.power(1.0 + n, 9) - - 1409.0 * np.power(1.0 + n, 10) - - 96.0 * np.power(1.0 + n, 11) - - 3.0 * np.power(1.0 + n, 12) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - ) - - ( - 1.0 - * ( - -1.562824e6 - - 5.7933e6 * (1.0 + n) - - 9.66711e6 * np.power(1.0 + n, 2) - - 9.628272e6 * np.power(1.0 + n, 3) - - 6.401058e6 * np.power(1.0 + n, 4) - - 3.007494e6 * np.power(1.0 + n, 5) - - 1.029715e6 * np.power(1.0 + n, 6) - - 260424.0 * np.power(1.0 + n, 7) - - 48597.0 * np.power(1.0 + n, 8) - - 6570.0 * np.power(1.0 + n, 9) - - 615.0 * np.power(1.0 + n, 10) - - 36.0 * np.power(1.0 + n, 11) - - 1.0 * np.power(1.0 + n, 12) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - ( - -12076.0 - - 29100.0 * (1.0 + n) - - 30230.0 * np.power(1.0 + n, 2) - - 17964.0 * np.power(1.0 + n, 3) - - 6753.0 * np.power(1.0 + n, 4) - - 1656.0 * np.power(1.0 + n, 5) - - 260.0 * np.power(1.0 + n, 6) - - 24.0 * np.power(1.0 + n, 7) - - 1.0 * np.power(1.0 + n, 8) - ) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - ) - + ( + / (8.0 + n) + + n + * ( + -1.0 / np.power(8.0 + n, 5) + + 1.6449340668482262 / np.power(8.0 + n, 3) + - 0.8117424252833533 / (8.0 + n) + - ( + 1.0 + * ( 1 / (1.0 + n) + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) + (7.0 + 2.0 * (1.0 + n)) + * ( + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + S1 ) + ) + / np.power(8.0 + n, 4) + + ( + 1.6449340668482262 * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 1.0 + 1 / (1.0 + n) + + ( + (7.0 + 2.0 * (1.0 + n)) * ( - -12076.0 - - 29100.0 * (1.0 + n) - - 30230.0 * np.power(1.0 + n, 2) - - 17964.0 * np.power(1.0 + n, 3) - - 6753.0 * np.power(1.0 + n, 4) - - 1656.0 * np.power(1.0 + n, 5) - - 260.0 * np.power(1.0 + n, 6) - - 24.0 * np.power(1.0 + n, 7) - - 1.0 * np.power(1.0 + n, 8) + 252.0 + + 392.0 * (1.0 + n) + + 203.0 * np.power(1.0 + n, 2) + + 42.0 * np.power(1.0 + n, 3) + + 3.0 * np.power(1.0 + n, 4) ) - * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - ) - ) - ) - ) - / (6.0 + n) - + n - * ( - np.power(6.0 + n, -5) - - 0.8224670334241131 / np.power(6.0 + n, 3) - - (0.8224670334241131 * np.power(-1.0, 5.0 + n)) / np.power(6.0 + n, 3) - + 0.419833592426477 / np.power(6.0 + n, 2) - + (1.6218904955860713 * np.power(-1.0, 5.0 + n)) / np.power(6.0 + n, 2) - + (1.2020569031595942 * np.power(-1.0, 6.0 + n)) / np.power(6.0 + n, 2) - - 0.3382260105347306 / (6.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 5.0 + n) - * ( - 1 / (1.0 + n) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + S1 ) ) - / np.power(6.0 + n, 2) + / np.power(8.0 + n, 2) - ( - 0.8224670334241131 - * np.power(-1.0, 6.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - + ( - 2.0 - * (7.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) - * np.power(-1.0, n) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - ) - ) - / np.power(6.0 + n, 2) - + ( - np.power(-1.0, 6.0 + n) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * ( - 46.0 - + 70.0 * (1.0 + n) - + 39.0 * np.power(1.0 + n, 2) - + 10.0 * np.power(1.0 + n, 3) - + np.power(1.0 + n, 4) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - ) - ) - ) - / np.power(6.0 + n, 3) - + ( - np.power(-1.0, 6.0 + n) + 1.0 * ( - -1.0 * Sm21 - + Sm3 + np.power(1.0 + n, -3) + ( - 2.0 - * ( - 6196.0 - + 19110.0 * (1.0 + n) - + 25497.0 * np.power(1.0 + n, 2) - + 19295.0 * np.power(1.0 + n, 3) - + 9117.0 * np.power(1.0 + n, 4) - + 2775.0 * np.power(1.0 + n, 5) - + 535.0 * np.power(1.0 + n, 6) - + 60.0 * np.power(1.0 + n, 7) - + 3.0 * np.power(1.0 + n, 8) - ) - * np.power(-1.0, n) + 6.97339584e8 + + 3.525030432e9 * (1.0 + n) + + 8.293536336e9 * np.power(1.0 + n, 2) + + 1.2007529256e10 * np.power(1.0 + n, 3) + + 1.193375892e10 * np.power(1.0 + n, 4) + + 8.60864186e9 * np.power(1.0 + n, 5) + + 4.650892802e9 * np.power(1.0 + n, 6) + + 1.914862936e9 * np.power(1.0 + n, 7) + + 6.05522329e8 * np.power(1.0 + n, 8) + + 1.47044895e8 * np.power(1.0 + n, 9) + + 2.7198669e7 * np.power(1.0 + n, 10) + + 3.763711e6 * np.power(1.0 + n, 11) + + 377251.0 * np.power(1.0 + n, 12) + + 25865.0 * np.power(1.0 + n, 13) + + 1085.0 * np.power(1.0 + n, 14) + + 21.0 * np.power(1.0 + n, 15) ) / ( np.power(2.0 + n, 3) * np.power(3.0 + n, 3) * np.power(4.0 + n, 3) * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) ) + + S1 / np.power(1.0 + n, 2) + ( ( - -9656.0 - - 26544.0 * (1.0 + n) - - 29682.0 * np.power(1.0 + n, 2) - - 16521.0 * np.power(1.0 + n, 3) - - 3745.0 * np.power(1.0 + n, 4) - + 787.0 * np.power(1.0 + n, 5) - + 793.0 * np.power(1.0 + n, 6) - + 236.0 * np.power(1.0 + n, 7) - + 34.0 * np.power(1.0 + n, 8) - + 2.0 * np.power(1.0 + n, 9) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * ( - 46.0 - + 70.0 * (1.0 + n) - + 39.0 * np.power(1.0 + n, 2) - + 10.0 * np.power(1.0 + n, 3) - + np.power(1.0 + n, 4) + 773136.0 + + 2.554272e6 * (1.0 + n) + + 3.762752e6 * np.power(1.0 + n, 2) + + 3.23736e6 * np.power(1.0 + n, 3) + + 1.797035e6 * np.power(1.0 + n, 4) + + 671790.0 * np.power(1.0 + n, 5) + + 171248.0 * np.power(1.0 + n, 6) + + 29400.0 * np.power(1.0 + n, 7) + + 3255.0 * np.power(1.0 + n, 8) + + 210.0 * np.power(1.0 + n, 9) + + 6.0 * np.power(1.0 + n, 10) ) * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) ) / ( np.power(2.0 + n, 2) * np.power(3.0 + n, 2) * np.power(4.0 + n, 2) * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) ) - + ( - 1 / (1.0 + n) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * (5.0 + 5.0 * (1.0 + n) + np.power(1.0 + n, 2)) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1 - ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - 2.0 - * (5.0 + 2.0 * (1.0 + n)) - * ( - 46.0 - + 70.0 * (1.0 + n) - + 39.0 * np.power(1.0 + n, 2) - + 10.0 * np.power(1.0 + n, 3) - + np.power(1.0 + n, 4) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - ) - ) + + S21 ) ) - / np.power(6.0 + n, 2) + / np.power(8.0 + n, 2) ) ) - - 0.10602798528818422 + - 0.019847559824380426 * ( - -0.419833592426477 / (7.0 + n) - - (0.18119485915332012 * np.power(-1.0, 7.0 + n)) / (7.0 + n) - - (0.6010284515797971 * np.power(-1.0, 8.0 + n)) / (7.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 7.0 + n) + ( + -1.6449340668482262 * ( 1 / (1.0 + n) + ( - (7.0 + 2.0 * (1.0 + n)) + 4.0 + * (9.0 + 2.0 * (1.0 + n)) * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) ) ) / ( @@ -6529,139 +6491,130 @@ def F16(n, S1, Sm1, Sm2, Sm3, Sm21): * (5.0 + n) * (6.0 + n) * (7.0 + n) + * (8.0 + n) + * (9.0 + n) ) + S1 ) ) - / (7.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 8.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - + ( - 3.0 - * ( - 148.0 - + 168.0 * (1.0 + n) - + 73.0 * np.power(1.0 + n, 2) - + 14.0 * np.power(1.0 + n, 3) - + np.power(1.0 + n, 4) - ) - * np.power(-1.0, n) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - ) - ) - ) - / (7.0 + n) + / (9.0 + n) + ( - np.power(-1.0, 8.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - + ( - 9.0 - * ( - 3.7315776e7 - + 1.56477888e8 * (1.0 + n) - + 3.00572848e8 * np.power(1.0 + n, 2) - + 3.51218448e8 * np.power(1.0 + n, 3) - + 2.79551676e8 * np.power(1.0 + n, 4) - + 1.60708716e8 * np.power(1.0 + n, 5) - + 6.8959587e7 * np.power(1.0 + n, 6) - + 2.2477189e7 * np.power(1.0 + n, 7) - + 5.600212e6 * np.power(1.0 + n, 8) - + 1.062467e6 * np.power(1.0 + n, 9) - + 151200.0 * np.power(1.0 + n, 10) - + 15659.0 * np.power(1.0 + n, 11) - + 1116.0 * np.power(1.0 + n, 12) - + 49.0 * np.power(1.0 + n, 13) - + np.power(1.0 + n, 14) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - ) - + ( - ( - -2.69400384e8 - - 1.055773152e9 * (1.0 + n) - - 1.862215728e9 * np.power(1.0 + n, 2) - - 1.946883032e9 * np.power(1.0 + n, 3) - - 1.328424984e9 * np.power(1.0 + n, 4) - - 6.04538588e8 * np.power(1.0 + n, 5) - - 1.71139894e8 * np.power(1.0 + n, 6) - - 1.745252e7 * np.power(1.0 + n, 7) - + 8.746623e6 * np.power(1.0 + n, 8) - + 5.172041e6 * np.power(1.0 + n, 9) - + 1.470723e6 * np.power(1.0 + n, 10) - + 270665.0 * np.power(1.0 + n, 11) - + 33685.0 * np.power(1.0 + n, 12) - + 2759.0 * np.power(1.0 + n, 13) - + 135.0 * np.power(1.0 + n, 14) - + 3.0 * np.power(1.0 + n, 15) + np.power(1.0 + n, -3) + + ( + 6.0 + * ( + 2.1452686055424e13 + + 1.27193972324352e14 * (1.0 + n) + + 3.569135825824e14 * np.power(1.0 + n, 2) + + 6.28964181904288e14 * np.power(1.0 + n, 3) + + 7.79557064653264e14 * np.power(1.0 + n, 4) + + 7.2173981400876e14 * np.power(1.0 + n, 5) + + 5.17717816384772e14 * np.power(1.0 + n, 6) + + 2.94648846212476e14 * np.power(1.0 + n, 7) + + 1.35183891860404e14 * np.power(1.0 + n, 8) + + 5.0528576648611e13 * np.power(1.0 + n, 9) + + 1.5487423206191e13 * np.power(1.0 + n, 10) + + 3.905253305568e12 * np.power(1.0 + n, 11) + + 8.10278287284e11 * np.power(1.0 + n, 12) + + 1.37943606892e11 * np.power(1.0 + n, 13) + + 1.9149259574e10 * np.power(1.0 + n, 14) + + 2.145327532e9 * np.power(1.0 + n, 15) + + 1.90913568e8 * np.power(1.0 + n, 16) + + 1.3175883e7 * np.power(1.0 + n, 17) + + 679567.0 * np.power(1.0 + n, 18) + + 24640.0 * np.power(1.0 + n, 19) + + 560.0 * np.power(1.0 + n, 20) + + 6.0 * np.power(1.0 + n, 21) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + ) + + S21 + ) + / (9.0 + n) + + n + * ( + -1.0 / np.power(9.0 + n, 5) + + 1.6449340668482262 / np.power(9.0 + n, 3) + - 0.8117424252833533 / (9.0 + n) + - ( + 1.0 + * ( + 1 / (1.0 + n) + + ( + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 3.0 - * (7.0 + 2.0 * (1.0 + n)) - * ( - 20016.0 - + 47936.0 * (1.0 + n) - + 49184.0 * np.power(1.0 + n, 2) - + 28560.0 * np.power(1.0 + n, 3) - + 10321.0 * np.power(1.0 + n, 4) - + 2380.0 * np.power(1.0 + n, 5) - + 342.0 * np.power(1.0 + n, 6) - + 28.0 * np.power(1.0 + n, 7) - + np.power(1.0 + n, 8) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) ) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) + + S1 ) - + ( + ) + / np.power(9.0 + n, 4) + + ( + 1.6449340668482262 + * ( 1 / (1.0 + n) + ( - (7.0 + 2.0 * (1.0 + n)) - * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) + 13068.0 + + 26264.0 * (1.0 + n) + + 20307.0 * np.power(1.0 + n, 2) + + 7840.0 * np.power(1.0 + n, 3) + + 1610.0 * np.power(1.0 + n, 4) + + 168.0 * np.power(1.0 + n, 5) + + 7.0 * np.power(1.0 + n, 6) ) / ( (2.0 + n) @@ -6670,27 +6623,67 @@ def F16(n, S1, Sm1, Sm2, Sm3, Sm21): * (5.0 + n) * (6.0 + n) * (7.0 + n) + * (8.0 + n) ) + S1 ) + ) + / np.power(9.0 + n, 2) + - ( + 1.0 * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + np.power(1.0 + n, -3) + ( - 3.0 - * (7.0 + 2.0 * (1.0 + n)) + 2.0 * ( - 20016.0 - + 47936.0 * (1.0 + n) - + 49184.0 * np.power(1.0 + n, 2) - + 28560.0 * np.power(1.0 + n, 3) - + 10321.0 * np.power(1.0 + n, 4) - + 2380.0 * np.power(1.0 + n, 5) - + 342.0 * np.power(1.0 + n, 6) - + 28.0 * np.power(1.0 + n, 7) - + np.power(1.0 + n, 8) + 1.22980964256e11 + + 6.79202212752e11 * (1.0 + n) + + 1.762986212232e12 * np.power(1.0 + n, 2) + + 2.849976037428e12 * np.power(1.0 + n, 3) + + 3.208712317944e12 * np.power(1.0 + n, 4) + + 2.66793900071e12 * np.power(1.0 + n, 5) + + 1.696140569839e12 * np.power(1.0 + n, 6) + + 8.42534361945e11 * np.power(1.0 + n, 7) + + 3.31394293594e11 * np.power(1.0 + n, 8) + + 1.03973066426e11 * np.power(1.0 + n, 9) + + 2.6083138284e10 * np.power(1.0 + n, 10) + + 5.220244242e9 * np.power(1.0 + n, 11) + + 8.27501148e8 * np.power(1.0 + n, 12) + + 1.02512358e8 * np.power(1.0 + n, 13) + + 9.709175e6 * np.power(1.0 + n, 14) + + 678601.0 * np.power(1.0 + n, 15) + + 32970.0 * np.power(1.0 + n, 16) + + 994.0 * np.power(1.0 + n, 17) + + 14.0 * np.power(1.0 + n, 18) ) - * np.power(-1.0, n) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + ( + 3.8402064e7 + + 1.38523392e8 * (1.0 + n) + + 2.26358048e8 * np.power(1.0 + n, 2) + + 2.20651312e8 * np.power(1.0 + n, 3) + + 1.42622963e8 * np.power(1.0 + n, 4) + + 6.434848e7 * np.power(1.0 + n, 5) + + 2.07774e7 * np.power(1.0 + n, 6) + + 4.838848e6 * np.power(1.0 + n, 7) + + 807086.0 * np.power(1.0 + n, 8) + + 94080.0 * np.power(1.0 + n, 9) + + 7280.0 * np.power(1.0 + n, 10) + + 336.0 * np.power(1.0 + n, 11) + + 7.0 * np.power(1.0 + n, 12) + ) + * (1 / (1.0 + n) + S1) ) / ( np.power(2.0 + n, 2) @@ -6699,136 +6692,227 @@ def F16(n, S1, Sm1, Sm2, Sm3, Sm21): * np.power(5.0 + n, 2) * np.power(6.0 + n, 2) * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + S21 + ) + ) + / np.power(9.0 + n, 2) + ) + ) + + 0.003243204652309423 + * ( + ( + -1.6449340668482262 + * ( + 1 / (1.0 + n) + + ( + 3.0 + * ( + 342192.0 + + 781800.0 * (1.0 + n) + + 723680.0 * np.power(1.0 + n, 2) + + 359100.0 * np.power(1.0 + n, 3) + + 105455.0 * np.power(1.0 + n, 4) + + 18900.0 * np.power(1.0 + n, 5) + + 2030.0 * np.power(1.0 + n, 6) + + 120.0 * np.power(1.0 + n, 7) + + 3.0 * np.power(1.0 + n, 8) ) ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + ) + + S1 ) ) - / (7.0 + n) + / (10.0 + n) + + ( + np.power(1.0 + n, -3) + + ( + 3.0 + * ( + 3.183431862446899e16 + + 2.001696918700032e17 * (1.0 + n) + + 5.98808681111543e17 * np.power(1.0 + n, 2) + + 1.1319310863695514e18 * np.power(1.0 + n, 3) + + 1.5156493142882596e18 * np.power(1.0 + n, 4) + + 1.5282976372182676e18 * np.power(1.0 + n, 5) + + 1.2049970049036114e18 * np.power(1.0 + n, 6) + + 7.616938706128154e17 * np.power(1.0 + n, 7) + + 3.92747201355673e17 * np.power(1.0 + n, 8) + + 1.6722252430665453e17 * np.power(1.0 + n, 9) + + 5.92988929379218e16 * np.power(1.0 + n, 10) + + 1.7614071211379864e16 * np.power(1.0 + n, 11) + + 4.397465867910487e15 * np.power(1.0 + n, 12) + + 9.23902782587314e14 * np.power(1.0 + n, 13) + + 1.6322843101295e14 * np.power(1.0 + n, 14) + + 2.4179602098084e13 * np.power(1.0 + n, 15) + + 2.987313035113e12 * np.power(1.0 + n, 16) + + 3.05296487914e11 * np.power(1.0 + n, 17) + + 2.550145462e10 * np.power(1.0 + n, 18) + + 1.711289424e9 * np.power(1.0 + n, 19) + + 8.9968697e7 * np.power(1.0 + n, 20) + + 3.567374e6 * np.power(1.0 + n, 21) + + 100270.0 * np.power(1.0 + n, 22) + + 1780.0 * np.power(1.0 + n, 23) + + 15.0 * np.power(1.0 + n, 24) + ) + ) + / ( + np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + * np.power(10.0 + n, 3) + ) + + S1 / np.power(1.0 + n, 2) + + ( + 3.0 + * ( + 6.7586510592e10 + + 2.7735912e11 * (1.0 + n) + + 5.25886236e11 * np.power(1.0 + n, 2) + + 6.098325648e11 * np.power(1.0 + n, 3) + + 4.8346372324e11 * np.power(1.0 + n, 4) + + 2.77716663e11 * np.power(1.0 + n, 5) + + 1.195744907e11 * np.power(1.0 + n, 6) + + 3.937668588e10 * np.power(1.0 + n, 7) + + 1.0027662147e10 * np.power(1.0 + n, 8) + + 1.982481e9 * np.power(1.0 + n, 9) + + 3.0344942e8 * np.power(1.0 + n, 10) + + 3.560508e7 * np.power(1.0 + n, 11) + + 3.141418e6 * np.power(1.0 + n, 12) + + 201600.0 * np.power(1.0 + n, 13) + + 8880.0 * np.power(1.0 + n, 14) + + 240.0 * np.power(1.0 + n, 15) + + 3.0 * np.power(1.0 + n, 16) + ) + * (1 / (1.0 + n) + S1) + ) + / ( + np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + ) + + S21 + ) + / (10.0 + n) + n * ( - np.power(7.0 + n, -5) - - 0.8224670334241131 / np.power(7.0 + n, 3) - - (0.8224670334241131 * np.power(-1.0, 6.0 + n)) / np.power(7.0 + n, 3) - + 0.419833592426477 / np.power(7.0 + n, 2) - + (1.6218904955860713 * np.power(-1.0, 6.0 + n)) / np.power(7.0 + n, 2) - + (1.2020569031595942 * np.power(-1.0, 7.0 + n)) / np.power(7.0 + n, 2) - - 0.3382260105347306 / (7.0 + n) + -1.0 / np.power(10.0 + n, 5) + + 1.6449340668482262 / np.power(10.0 + n, 3) + - 0.8117424252833533 / (10.0 + n) - ( - 0.8224670334241131 - * np.power(-1.0, 6.0 + n) + 1.0 * ( 1 / (1.0 + n) + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) - ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) - + S1 - ) - ) - / np.power(7.0 + n, 2) - - ( - 0.8224670334241131 - * np.power(-1.0, 7.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - - ( - 1.0 + 4.0 + * (9.0 + 2.0 * (1.0 + n)) * ( - -94.0 - - 114.0 * (1.0 + n) - - 55.0 * np.power(1.0 + n, 2) - - 12.0 * np.power(1.0 + n, 3) - - 1.0 * np.power(1.0 + n, 4) + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) ) - * np.power(-1.0, n) ) - / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n) * (6.0 + n)) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + ) + + S1 ) ) - / np.power(7.0 + n, 2) + / np.power(10.0 + n, 4) + ( - np.power(-1.0, 7.0 + n) + 1.6449340668482262 * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 1.0 + 1 / (1.0 + n) + + ( + 4.0 + * (9.0 + 2.0 * (1.0 + n)) * ( - -12076.0 - - 29100.0 * (1.0 + n) - - 30230.0 * np.power(1.0 + n, 2) - - 17964.0 * np.power(1.0 + n, 3) - - 6753.0 * np.power(1.0 + n, 4) - - 1656.0 * np.power(1.0 + n, 5) - - 260.0 * np.power(1.0 + n, 6) - - 24.0 * np.power(1.0 + n, 7) - - 1.0 * np.power(1.0 + n, 8) + 3044.0 + + 5886.0 * (1.0 + n) + + 4299.0 * np.power(1.0 + n, 2) + + 1539.0 * np.power(1.0 + n, 3) + + 288.0 * np.power(1.0 + n, 4) + + 27.0 * np.power(1.0 + n, 5) + + np.power(1.0 + n, 6) ) - * np.power(-1.0, n) ) / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) ) + + S1 ) ) - / np.power(7.0 + n, 3) - + ( - np.power(-1.0, 7.0 + n) + / np.power(10.0 + n, 2) + - ( + 1.0 * ( - -1.0 * Sm21 - + Sm3 + np.power(1.0 + n, -3) + ( - ( - -1.364824e6 - - 4.959e6 * (1.0 + n) - - 8.21809e6 * np.power(1.0 + n, 2) - - 8.317171e6 * np.power(1.0 + n, 3) - - 5.805556e6 * np.power(1.0 + n, 4) - - 2.979747e6 * np.power(1.0 + n, 5) - - 1.160441e6 * np.power(1.0 + n, 6) - - 345225.0 * np.power(1.0 + n, 7) - - 77357.0 * np.power(1.0 + n, 8) - - 12617.0 * np.power(1.0 + n, 9) - - 1409.0 * np.power(1.0 + n, 10) - - 96.0 * np.power(1.0 + n, 11) - - 3.0 * np.power(1.0 + n, 12) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - ) - - ( - 1.0 + 6.0 * ( - -1.562824e6 - - 5.7933e6 * (1.0 + n) - - 9.66711e6 * np.power(1.0 + n, 2) - - 9.628272e6 * np.power(1.0 + n, 3) - - 6.401058e6 * np.power(1.0 + n, 4) - - 3.007494e6 * np.power(1.0 + n, 5) - - 1.029715e6 * np.power(1.0 + n, 6) - - 260424.0 * np.power(1.0 + n, 7) - - 48597.0 * np.power(1.0 + n, 8) - - 6570.0 * np.power(1.0 + n, 9) - - 615.0 * np.power(1.0 + n, 10) - - 36.0 * np.power(1.0 + n, 11) - - 1.0 * np.power(1.0 + n, 12) + 2.1452686055424e13 + + 1.27193972324352e14 * (1.0 + n) + + 3.569135825824e14 * np.power(1.0 + n, 2) + + 6.28964181904288e14 * np.power(1.0 + n, 3) + + 7.79557064653264e14 * np.power(1.0 + n, 4) + + 7.2173981400876e14 * np.power(1.0 + n, 5) + + 5.17717816384772e14 * np.power(1.0 + n, 6) + + 2.94648846212476e14 * np.power(1.0 + n, 7) + + 1.35183891860404e14 * np.power(1.0 + n, 8) + + 5.0528576648611e13 * np.power(1.0 + n, 9) + + 1.5487423206191e13 * np.power(1.0 + n, 10) + + 3.905253305568e12 * np.power(1.0 + n, 11) + + 8.10278287284e11 * np.power(1.0 + n, 12) + + 1.37943606892e11 * np.power(1.0 + n, 13) + + 1.9149259574e10 * np.power(1.0 + n, 14) + + 2.145327532e9 * np.power(1.0 + n, 15) + + 1.90913568e8 * np.power(1.0 + n, 16) + + 1.3175883e7 * np.power(1.0 + n, 17) + + 679567.0 * np.power(1.0 + n, 18) + + 24640.0 * np.power(1.0 + n, 19) + + 560.0 * np.power(1.0 + n, 20) + + 6.0 * np.power(1.0 + n, 21) ) - * np.power(-1.0, n) ) / ( np.power(2.0 + n, 3) @@ -6836,22 +6920,31 @@ def F16(n, S1, Sm1, Sm2, Sm3, Sm21): * np.power(4.0 + n, 3) * np.power(5.0 + n, 3) * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) + + S1 / np.power(1.0 + n, 2) + ( - ( - -12076.0 - - 29100.0 * (1.0 + n) - - 30230.0 * np.power(1.0 + n, 2) - - 17964.0 * np.power(1.0 + n, 3) - - 6753.0 * np.power(1.0 + n, 4) - - 1656.0 * np.power(1.0 + n, 5) - - 260.0 * np.power(1.0 + n, 6) - - 24.0 * np.power(1.0 + n, 7) - - 1.0 * np.power(1.0 + n, 8) + 4.0 + * ( + 6.20783424e8 + + 2.402913888e9 * (1.0 + n) + + 4.261208648e9 * np.power(1.0 + n, 2) + + 4.5733464e9 * np.power(1.0 + n, 3) + + 3.31344237e9 * np.power(1.0 + n, 4) + + 1.713293694e9 * np.power(1.0 + n, 5) + + 6.51986769e8 * np.power(1.0 + n, 6) + + 1.85551632e8 * np.power(1.0 + n, 7) + + 3.9703709e7 * np.power(1.0 + n, 8) + + 6.360228e6 * np.power(1.0 + n, 9) + + 751317.0 * np.power(1.0 + n, 10) + + 63504.0 * np.power(1.0 + n, 11) + + 3633.0 * np.power(1.0 + n, 12) + + 126.0 * np.power(1.0 + n, 13) + + 2.0 * np.power(1.0 + n, 14) ) * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) ) / ( np.power(2.0 + n, 2) @@ -6859,1859 +6952,14 @@ def F16(n, S1, Sm1, Sm2, Sm3, Sm21): * np.power(4.0 + n, 2) * np.power(5.0 + n, 2) * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) ) - + ( - 1 / (1.0 + n) - + ( - 274.0 - + 450.0 * (1.0 + n) - + 255.0 * np.power(1.0 + n, 2) - + 60.0 * np.power(1.0 + n, 3) - + 5.0 * np.power(1.0 + n, 4) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - ) - + S1 - ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 1.0 - * ( - -12076.0 - - 29100.0 * (1.0 + n) - - 30230.0 * np.power(1.0 + n, 2) - - 17964.0 * np.power(1.0 + n, 3) - - 6753.0 * np.power(1.0 + n, 4) - - 1656.0 * np.power(1.0 + n, 5) - - 260.0 * np.power(1.0 + n, 6) - - 24.0 * np.power(1.0 + n, 7) - - 1.0 * np.power(1.0 + n, 8) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - ) - ) + + S21 ) ) - / np.power(7.0 + n, 2) + / np.power(10.0 + n, 2) ) ) - + 0.056951717764149916 - * ( - -0.419833592426477 / (8.0 + n) - - (0.18119485915332012 * np.power(-1.0, 8.0 + n)) / (8.0 + n) - - (0.6010284515797971 * np.power(-1.0, 9.0 + n)) / (8.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 8.0 + n) - * ( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + S1 - ) - ) - / (8.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 9.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - - ( - 1.0 - * ( - -3828.0 - - 5736.0 * (1.0 + n) - - 3661.0 * np.power(1.0 + n, 2) - - 1248.0 * np.power(1.0 + n, 3) - - 238.0 * np.power(1.0 + n, 4) - - 24.0 * np.power(1.0 + n, 5) - - 1.0 * np.power(1.0 + n, 6) - ) - * np.power(-1.0, n) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - ) - ) - / (8.0 + n) - + ( - np.power(-1.0, 9.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - - ( - 1.0 - * ( - -1.15567048512e11 - - 5.35159384704e11 * (1.0 + n) - - 1.151188217424e12 * np.power(1.0 + n, 2) - - 1.53078715296e12 * np.power(1.0 + n, 3) - - 1.412584727652e12 * np.power(1.0 + n, 4) - - 9.62381167416e11 * np.power(1.0 + n, 5) - - 5.02598549197e11 * np.power(1.0 + n, 6) - - 2.0609943264e11 * np.power(1.0 + n, 7) - - 6.7393018182e10 * np.power(1.0 + n, 8) - - 1.7735954328e10 * np.power(1.0 + n, 9) - - 3.772650903e9 * np.power(1.0 + n, 10) - - 6.48395136e8 * np.power(1.0 + n, 11) - - 8.9565928e7 * np.power(1.0 + n, 12) - - 9.831528e6 * np.power(1.0 + n, 13) - - 840651.0 * np.power(1.0 + n, 14) - - 54144.0 * np.power(1.0 + n, 15) - - 2478.0 * np.power(1.0 + n, 16) - - 72.0 * np.power(1.0 + n, 17) - - 1.0 * np.power(1.0 + n, 18) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - ) - - ( - 2.0 - * ( - 4.9589391456e10 - + 2.24271058032e11 * (1.0 + n) - + 4.7403095628e11 * np.power(1.0 + n, 2) - + 6.25731974284e11 * np.power(1.0 + n, 3) - + 5.81676555432e11 * np.power(1.0 + n, 4) - + 4.0689079961e11 * np.power(1.0 + n, 5) - + 2.23175026185e11 * np.power(1.0 + n, 6) - + 9.8520885539e10 * np.power(1.0 + n, 7) - + 3.554804558e10 * np.power(1.0 + n, 8) - + 1.0556408108e10 * np.power(1.0 + n, 9) - + 2.579863556e9 * np.power(1.0 + n, 10) - + 5.15736142e8 * np.power(1.0 + n, 11) - + 8.3361904e7 * np.power(1.0 + n, 12) - + 1.0703902e7 * np.power(1.0 + n, 13) - + 1.064065e6 * np.power(1.0 + n, 14) - + 78795.0 * np.power(1.0 + n, 15) - + 4084.0 * np.power(1.0 + n, 16) - + 132.0 * np.power(1.0 + n, 17) - + 2.0 * np.power(1.0 + n, 18) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - ( - -2.1114864e7 - - 6.3635712e7 * (1.0 + n) - - 8.634864e7 * np.power(1.0 + n, 2) - - 7.024968e7 * np.power(1.0 + n, 3) - - 3.8347981e7 * np.power(1.0 + n, 4) - - 1.4846592e7 * np.power(1.0 + n, 5) - - 4.190576e6 * np.power(1.0 + n, 6) - - 870720.0 * np.power(1.0 + n, 7) - - 132426.0 * np.power(1.0 + n, 8) - - 14400.0 * np.power(1.0 + n, 9) - - 1064.0 * np.power(1.0 + n, 10) - - 48.0 * np.power(1.0 + n, 11) - - 1.0 * np.power(1.0 + n, 12) - ) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - ) - + ( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + S1 - ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 1.0 - * ( - -2.1114864e7 - - 6.3635712e7 * (1.0 + n) - - 8.634864e7 * np.power(1.0 + n, 2) - - 7.024968e7 * np.power(1.0 + n, 3) - - 3.8347981e7 * np.power(1.0 + n, 4) - - 1.4846592e7 * np.power(1.0 + n, 5) - - 4.190576e6 * np.power(1.0 + n, 6) - - 870720.0 * np.power(1.0 + n, 7) - - 132426.0 * np.power(1.0 + n, 8) - - 14400.0 * np.power(1.0 + n, 9) - - 1064.0 * np.power(1.0 + n, 10) - - 48.0 * np.power(1.0 + n, 11) - - 1.0 * np.power(1.0 + n, 12) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - ) - ) - ) - ) - / (8.0 + n) - + n - * ( - np.power(8.0 + n, -5) - - 0.8224670334241131 / np.power(8.0 + n, 3) - - (0.8224670334241131 * np.power(-1.0, 7.0 + n)) / np.power(8.0 + n, 3) - + 0.419833592426477 / np.power(8.0 + n, 2) - + (1.6218904955860713 * np.power(-1.0, 7.0 + n)) / np.power(8.0 + n, 2) - + (1.2020569031595942 * np.power(-1.0, 8.0 + n)) / np.power(8.0 + n, 2) - - 0.3382260105347306 / (8.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 7.0 + n) - * ( - 1 / (1.0 + n) - + ( - (7.0 + 2.0 * (1.0 + n)) - * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - ) - + S1 - ) - ) - / np.power(8.0 + n, 2) - - ( - 0.8224670334241131 - * np.power(-1.0, 8.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - + ( - 3.0 - * ( - 148.0 - + 168.0 * (1.0 + n) - + 73.0 * np.power(1.0 + n, 2) - + 14.0 * np.power(1.0 + n, 3) - + np.power(1.0 + n, 4) - ) - * np.power(-1.0, n) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - ) - ) - ) - / np.power(8.0 + n, 2) - + ( - np.power(-1.0, 8.0 + n) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - 3.0 - * (7.0 + 2.0 * (1.0 + n)) - * ( - 20016.0 - + 47936.0 * (1.0 + n) - + 49184.0 * np.power(1.0 + n, 2) - + 28560.0 * np.power(1.0 + n, 3) - + 10321.0 * np.power(1.0 + n, 4) - + 2380.0 * np.power(1.0 + n, 5) - + 342.0 * np.power(1.0 + n, 6) - + 28.0 * np.power(1.0 + n, 7) - + np.power(1.0 + n, 8) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - ) - ) - ) - / np.power(8.0 + n, 3) - + ( - np.power(-1.0, 8.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - + ( - 9.0 - * ( - 3.7315776e7 - + 1.56477888e8 * (1.0 + n) - + 3.00572848e8 * np.power(1.0 + n, 2) - + 3.51218448e8 * np.power(1.0 + n, 3) - + 2.79551676e8 * np.power(1.0 + n, 4) - + 1.60708716e8 * np.power(1.0 + n, 5) - + 6.8959587e7 * np.power(1.0 + n, 6) - + 2.2477189e7 * np.power(1.0 + n, 7) - + 5.600212e6 * np.power(1.0 + n, 8) - + 1.062467e6 * np.power(1.0 + n, 9) - + 151200.0 * np.power(1.0 + n, 10) - + 15659.0 * np.power(1.0 + n, 11) - + 1116.0 * np.power(1.0 + n, 12) - + 49.0 * np.power(1.0 + n, 13) - + np.power(1.0 + n, 14) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - ) - + ( - ( - -2.69400384e8 - - 1.055773152e9 * (1.0 + n) - - 1.862215728e9 * np.power(1.0 + n, 2) - - 1.946883032e9 * np.power(1.0 + n, 3) - - 1.328424984e9 * np.power(1.0 + n, 4) - - 6.04538588e8 * np.power(1.0 + n, 5) - - 1.71139894e8 * np.power(1.0 + n, 6) - - 1.745252e7 * np.power(1.0 + n, 7) - + 8.746623e6 * np.power(1.0 + n, 8) - + 5.172041e6 * np.power(1.0 + n, 9) - + 1.470723e6 * np.power(1.0 + n, 10) - + 270665.0 * np.power(1.0 + n, 11) - + 33685.0 * np.power(1.0 + n, 12) - + 2759.0 * np.power(1.0 + n, 13) - + 135.0 * np.power(1.0 + n, 14) - + 3.0 * np.power(1.0 + n, 15) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 3.0 - * (7.0 + 2.0 * (1.0 + n)) - * ( - 20016.0 - + 47936.0 * (1.0 + n) - + 49184.0 * np.power(1.0 + n, 2) - + 28560.0 * np.power(1.0 + n, 3) - + 10321.0 * np.power(1.0 + n, 4) - + 2380.0 * np.power(1.0 + n, 5) - + 342.0 * np.power(1.0 + n, 6) - + 28.0 * np.power(1.0 + n, 7) - + np.power(1.0 + n, 8) - ) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - ) - + ( - 1 / (1.0 + n) - + ( - (7.0 + 2.0 * (1.0 + n)) - * ( - 252.0 - + 392.0 * (1.0 + n) - + 203.0 * np.power(1.0 + n, 2) - + 42.0 * np.power(1.0 + n, 3) - + 3.0 * np.power(1.0 + n, 4) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - ) - + S1 - ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - 3.0 - * (7.0 + 2.0 * (1.0 + n)) - * ( - 20016.0 - + 47936.0 * (1.0 + n) - + 49184.0 * np.power(1.0 + n, 2) - + 28560.0 * np.power(1.0 + n, 3) - + 10321.0 * np.power(1.0 + n, 4) - + 2380.0 * np.power(1.0 + n, 5) - + 342.0 * np.power(1.0 + n, 6) - + 28.0 * np.power(1.0 + n, 7) - + np.power(1.0 + n, 8) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - ) - ) - ) - ) - / np.power(8.0 + n, 2) - ) - ) - - 0.019847559824380426 - * ( - -0.419833592426477 / (9.0 + n) - - (0.18119485915332012 * np.power(-1.0, 9.0 + n)) / (9.0 + n) - - (0.6010284515797971 * np.power(-1.0, 10.0 + n)) / (9.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 9.0 + n) - * ( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1 - ) - ) - / (9.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 10.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - + ( - 4.0 - * ( - 6396.0 - + 9162.0 * (1.0 + n) - + 5473.0 * np.power(1.0 + n, 2) - + 1719.0 * np.power(1.0 + n, 3) - + 298.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - * np.power(-1.0, n) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - ) - ) - / (9.0 + n) - + ( - np.power(-1.0, 10.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - + ( - 4.0 - * ( - 1.4760576193536e13 - + 7.3798658489088e13 * (1.0 + n) - + 1.72837443710016e14 * np.power(1.0 + n, 2) - + 2.52453402491616e14 * np.power(1.0 + n, 3) - + 2.5828967175624e14 * np.power(1.0 + n, 4) - + 1.97032446481464e14 * np.power(1.0 + n, 5) - + 1.16425369498108e14 * np.power(1.0 + n, 6) - + 5.4627507667116e13 * np.power(1.0 + n, 7) - + 2.0690074606371e13 * np.power(1.0 + n, 8) - + 6.392775359655e12 * np.power(1.0 + n, 9) - + 1.621160332314e12 * np.power(1.0 + n, 10) - + 3.38175413478e11 * np.power(1.0 + n, 11) - + 5.7948536701e10 * np.power(1.0 + n, 12) - + 8.115008166e9 * np.power(1.0 + n, 13) - + 9.1986012e8 * np.power(1.0 + n, 14) - + 8.3116584e7 * np.power(1.0 + n, 15) - + 5.847213e6 * np.power(1.0 + n, 16) - + 308691.0 * np.power(1.0 + n, 17) - + 11506.0 * np.power(1.0 + n, 18) - + 270.0 * np.power(1.0 + n, 19) - + 3.0 * np.power(1.0 + n, 20) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) - ) - + ( - 2.0 - * ( - -2.3997963958272e13 - - 1.14129905965056e14 * (1.0 + n) - - 2.5222059905856e14 * np.power(1.0 + n, 2) - - 3.44033181492512e14 * np.power(1.0 + n, 3) - - 3.23935732772496e14 * np.power(1.0 + n, 4) - - 2.22502088875352e14 * np.power(1.0 + n, 5) - - 1.14348498644148e14 * np.power(1.0 + n, 6) - - 4.3968646592044e13 * np.power(1.0 + n, 7) - - 1.21438136977e13 * np.power(1.0 + n, 8) - - 2.010931672623e12 * np.power(1.0 + n, 9) - + 4.9482178305e10 * np.power(1.0 + n, 10) - + 1.59991878826e11 * np.power(1.0 + n, 11) - + 6.0723226806e10 * np.power(1.0 + n, 12) - + 1.4651858516e10 * np.power(1.0 + n, 13) - + 2.59766429e9 * np.power(1.0 + n, 14) - + 3.51680472e8 * np.power(1.0 + n, 15) - + 3.6575004e7 * np.power(1.0 + n, 16) - + 2.886025e6 * np.power(1.0 + n, 17) - + 167625.0 * np.power(1.0 + n, 18) - + 6770.0 * np.power(1.0 + n, 19) - + 170.0 * np.power(1.0 + n, 20) - + 2.0 * np.power(1.0 + n, 21) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) - ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3.6831936e7 - + 1.10670624e8 * (1.0 + n) - + 1.4936364e8 * np.power(1.0 + n, 2) - + 1.2041208e8 * np.power(1.0 + n, 3) - + 6.4783246e7 * np.power(1.0 + n, 4) - + 2.454111e7 * np.power(1.0 + n, 5) - + 6.715739e6 * np.power(1.0 + n, 6) - + 1.33785e6 * np.power(1.0 + n, 7) - + 192561.0 * np.power(1.0 + n, 8) - + 19530.0 * np.power(1.0 + n, 9) - + 1325.0 * np.power(1.0 + n, 10) - + 54.0 * np.power(1.0 + n, 11) - + np.power(1.0 + n, 12) - ) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - ) - + ( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1 - ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3.6831936e7 - + 1.10670624e8 * (1.0 + n) - + 1.4936364e8 * np.power(1.0 + n, 2) - + 1.2041208e8 * np.power(1.0 + n, 3) - + 6.4783246e7 * np.power(1.0 + n, 4) - + 2.454111e7 * np.power(1.0 + n, 5) - + 6.715739e6 * np.power(1.0 + n, 6) - + 1.33785e6 * np.power(1.0 + n, 7) - + 192561.0 * np.power(1.0 + n, 8) - + 19530.0 * np.power(1.0 + n, 9) - + 1325.0 * np.power(1.0 + n, 10) - + 54.0 * np.power(1.0 + n, 11) - + np.power(1.0 + n, 12) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - ) - ) - ) - ) - / (9.0 + n) - + n - * ( - np.power(9.0 + n, -5) - - 0.8224670334241131 / np.power(9.0 + n, 3) - - (0.8224670334241131 * np.power(-1.0, 8.0 + n)) / np.power(9.0 + n, 3) - + 0.419833592426477 / np.power(9.0 + n, 2) - + (1.6218904955860713 * np.power(-1.0, 8.0 + n)) / np.power(9.0 + n, 2) - + (1.2020569031595942 * np.power(-1.0, 9.0 + n)) / np.power(9.0 + n, 2) - - 0.3382260105347306 / (9.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 8.0 + n) - * ( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + S1 - ) - ) - / np.power(9.0 + n, 2) - - ( - 0.8224670334241131 - * np.power(-1.0, 9.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - - ( - 1.0 - * ( - -3828.0 - - 5736.0 * (1.0 + n) - - 3661.0 * np.power(1.0 + n, 2) - - 1248.0 * np.power(1.0 + n, 3) - - 238.0 * np.power(1.0 + n, 4) - - 24.0 * np.power(1.0 + n, 5) - - 1.0 * np.power(1.0 + n, 6) - ) - * np.power(-1.0, n) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - ) - ) - / np.power(9.0 + n, 2) - + ( - np.power(-1.0, 9.0 + n) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 1.0 - * ( - -2.1114864e7 - - 6.3635712e7 * (1.0 + n) - - 8.634864e7 * np.power(1.0 + n, 2) - - 7.024968e7 * np.power(1.0 + n, 3) - - 3.8347981e7 * np.power(1.0 + n, 4) - - 1.4846592e7 * np.power(1.0 + n, 5) - - 4.190576e6 * np.power(1.0 + n, 6) - - 870720.0 * np.power(1.0 + n, 7) - - 132426.0 * np.power(1.0 + n, 8) - - 14400.0 * np.power(1.0 + n, 9) - - 1064.0 * np.power(1.0 + n, 10) - - 48.0 * np.power(1.0 + n, 11) - - 1.0 * np.power(1.0 + n, 12) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - ) - ) - ) - / np.power(9.0 + n, 3) - + ( - np.power(-1.0, 9.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - - ( - 1.0 - * ( - -1.15567048512e11 - - 5.35159384704e11 * (1.0 + n) - - 1.151188217424e12 * np.power(1.0 + n, 2) - - 1.53078715296e12 * np.power(1.0 + n, 3) - - 1.412584727652e12 * np.power(1.0 + n, 4) - - 9.62381167416e11 * np.power(1.0 + n, 5) - - 5.02598549197e11 * np.power(1.0 + n, 6) - - 2.0609943264e11 * np.power(1.0 + n, 7) - - 6.7393018182e10 * np.power(1.0 + n, 8) - - 1.7735954328e10 * np.power(1.0 + n, 9) - - 3.772650903e9 * np.power(1.0 + n, 10) - - 6.48395136e8 * np.power(1.0 + n, 11) - - 8.9565928e7 * np.power(1.0 + n, 12) - - 9.831528e6 * np.power(1.0 + n, 13) - - 840651.0 * np.power(1.0 + n, 14) - - 54144.0 * np.power(1.0 + n, 15) - - 2478.0 * np.power(1.0 + n, 16) - - 72.0 * np.power(1.0 + n, 17) - - 1.0 * np.power(1.0 + n, 18) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - ) - - ( - 2.0 - * ( - 4.9589391456e10 - + 2.24271058032e11 * (1.0 + n) - + 4.7403095628e11 * np.power(1.0 + n, 2) - + 6.25731974284e11 * np.power(1.0 + n, 3) - + 5.81676555432e11 * np.power(1.0 + n, 4) - + 4.0689079961e11 * np.power(1.0 + n, 5) - + 2.23175026185e11 * np.power(1.0 + n, 6) - + 9.8520885539e10 * np.power(1.0 + n, 7) - + 3.554804558e10 * np.power(1.0 + n, 8) - + 1.0556408108e10 * np.power(1.0 + n, 9) - + 2.579863556e9 * np.power(1.0 + n, 10) - + 5.15736142e8 * np.power(1.0 + n, 11) - + 8.3361904e7 * np.power(1.0 + n, 12) - + 1.0703902e7 * np.power(1.0 + n, 13) - + 1.064065e6 * np.power(1.0 + n, 14) - + 78795.0 * np.power(1.0 + n, 15) - + 4084.0 * np.power(1.0 + n, 16) - + 132.0 * np.power(1.0 + n, 17) - + 2.0 * np.power(1.0 + n, 18) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - ( - -2.1114864e7 - - 6.3635712e7 * (1.0 + n) - - 8.634864e7 * np.power(1.0 + n, 2) - - 7.024968e7 * np.power(1.0 + n, 3) - - 3.8347981e7 * np.power(1.0 + n, 4) - - 1.4846592e7 * np.power(1.0 + n, 5) - - 4.190576e6 * np.power(1.0 + n, 6) - - 870720.0 * np.power(1.0 + n, 7) - - 132426.0 * np.power(1.0 + n, 8) - - 14400.0 * np.power(1.0 + n, 9) - - 1064.0 * np.power(1.0 + n, 10) - - 48.0 * np.power(1.0 + n, 11) - - 1.0 * np.power(1.0 + n, 12) - ) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - ) - + ( - 1 / (1.0 + n) - + ( - 13068.0 - + 26264.0 * (1.0 + n) - + 20307.0 * np.power(1.0 + n, 2) - + 7840.0 * np.power(1.0 + n, 3) - + 1610.0 * np.power(1.0 + n, 4) - + 168.0 * np.power(1.0 + n, 5) - + 7.0 * np.power(1.0 + n, 6) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + S1 - ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 1.0 - * ( - -2.1114864e7 - - 6.3635712e7 * (1.0 + n) - - 8.634864e7 * np.power(1.0 + n, 2) - - 7.024968e7 * np.power(1.0 + n, 3) - - 3.8347981e7 * np.power(1.0 + n, 4) - - 1.4846592e7 * np.power(1.0 + n, 5) - - 4.190576e6 * np.power(1.0 + n, 6) - - 870720.0 * np.power(1.0 + n, 7) - - 132426.0 * np.power(1.0 + n, 8) - - 14400.0 * np.power(1.0 + n, 9) - - 1064.0 * np.power(1.0 + n, 10) - - 48.0 * np.power(1.0 + n, 11) - - 1.0 * np.power(1.0 + n, 12) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - ) - ) - ) - ) - / np.power(9.0 + n, 2) - ) - ) - + 0.003243204652309423 - * ( - -0.419833592426477 / (10.0 + n) - - (0.18119485915332012 * np.power(-1.0, 10.0 + n)) / (10.0 + n) - - (0.6010284515797971 * np.power(-1.0, 11.0 + n)) / (10.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 10.0 + n) - * ( - 1 / (1.0 + n) - + ( - 3.0 - * ( - 342192.0 - + 781800.0 * (1.0 + n) - + 723680.0 * np.power(1.0 + n, 2) - + 359100.0 * np.power(1.0 + n, 3) - + 105455.0 * np.power(1.0 + n, 4) - + 18900.0 * np.power(1.0 + n, 5) - + 2030.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 3.0 * np.power(1.0 + n, 8) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - ) - + S1 - ) - ) - / (10.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 11.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - - ( - 1.0 - * ( - -270576.0 - - 465000.0 * (1.0 + n) - - 351800.0 * np.power(1.0 + n, 2) - - 151060.0 * np.power(1.0 + n, 3) - - 40053.0 * np.power(1.0 + n, 4) - - 6700.0 * np.power(1.0 + n, 5) - - 690.0 * np.power(1.0 + n, 6) - - 40.0 * np.power(1.0 + n, 7) - - 1.0 * np.power(1.0 + n, 8) - ) - * np.power(-1.0, n) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - ) - ) - ) - / (10.0 + n) - + ( - np.power(-1.0, 11.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - + ( - ( - -3.665793851814298e16 - - 1.909490377752576e17 * (1.0 + n) - - 4.70862544109472e17 * np.power(1.0 + n, 2) - - 7.33980385029854e17 * np.power(1.0 + n, 3) - - 8.148989973914079e17 * np.power(1.0 + n, 4) - - 6.882981306584479e17 * np.power(1.0 + n, 5) - - 4.611713296031033e17 * np.power(1.0 + n, 6) - - 2.5219843129581005e17 * np.power(1.0 + n, 7) - - 1.14842783872951e17 * np.power(1.0 + n, 8) - - 4.415488009076552e16 * np.power(1.0 + n, 9) - - 1.44652124073368e16 * np.power(1.0 + n, 10) - - 4.05880131245378e15 * np.power(1.0 + n, 11) - - 9.77306344262685e14 * np.power(1.0 + n, 12) - - 2.01769269859842e14 * np.power(1.0 + n, 13) - - 3.560081466145e13 * np.power(1.0 + n, 14) - - 5.339127383592e12 * np.power(1.0 + n, 15) - - 6.75333270995e11 * np.power(1.0 + n, 16) - - 7.1298201266e10 * np.power(1.0 + n, 17) - - 6.19612062e9 * np.power(1.0 + n, 18) - - 4.34978004e8 * np.power(1.0 + n, 19) - - 2.4024499e7 * np.power(1.0 + n, 20) - - 1.00395e6 * np.power(1.0 + n, 21) - - 29810.0 * np.power(1.0 + n, 22) - - 560.0 * np.power(1.0 + n, 23) - - 5.0 * np.power(1.0 + n, 24) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) - * np.power(10.0 + n, 3) - ) - - ( - 1.0 - * ( - -4.310738850111898e16 - - 2.300786211297024e17 * (1.0 + n) - - 5.793490942232486e17 * np.power(1.0 + n, 2) - - 9.169570554312557e17 * np.power(1.0 + n, 3) - - 1.0253555704764628e18 * np.power(1.0 + n, 4) - - 8.63111634551316e17 * np.power(1.0 + n, 5) - - 5.689117565311652e17 * np.power(1.0 + n, 6) - - 3.014933810188104e17 * np.power(1.0 + n, 7) - - 1.3085272169429526e17 * np.power(1.0 + n, 8) - - 4.712719391395e16 * np.power(1.0 + n, 9) - - 1.42167692592585e16 * np.power(1.0 + n, 10) - - 3.6154166212347e15 * np.power(1.0 + n, 11) - - 7.78200392291745e14 * np.power(1.0 + n, 12) - - 1.420469104479e14 * np.power(1.0 + n, 13) - - 2.198557186497e13 * np.power(1.0 + n, 14) - - 2.8791357052e12 * np.power(1.0 + n, 15) - - 3.17567574315e11 * np.power(1.0 + n, 16) - - 2.92849434e10 * np.power(1.0 + n, 17) - - 2.23273176e9 * np.power(1.0 + n, 18) - - 1.384419e8 * np.power(1.0 + n, 19) - - 6.812919e6 * np.power(1.0 + n, 20) - - 256300.0 * np.power(1.0 + n, 21) - - 6930.0 * np.power(1.0 + n, 22) - - 120.0 * np.power(1.0 + n, 23) - - 1.0 * np.power(1.0 + n, 24) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) - * np.power(10.0 + n, 3) - ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - ( - -1.09027627776e11 - - 3.792865824e11 * (1.0 + n) - - 6.0713742384e11 * np.power(1.0 + n, 2) - - 5.9622705312e11 * np.power(1.0 + n, 3) - - 4.03242887656e11 * np.power(1.0 + n, 4) - - 1.99571643e11 * np.power(1.0 + n, 5) - - 7.48814979e10 * np.power(1.0 + n, 6) - - 2.175554084e10 * np.power(1.0 + n, 7) - - 4.951843521e9 * np.power(1.0 + n, 8) - - 8.86903e8 * np.power(1.0 + n, 9) - - 1.2470866e8 * np.power(1.0 + n, 10) - - 1.363476e7 * np.power(1.0 + n, 11) - - 1.137246e6 * np.power(1.0 + n, 12) - - 70000.0 * np.power(1.0 + n, 13) - - 3000.0 * np.power(1.0 + n, 14) - - 80.0 * np.power(1.0 + n, 15) - - 1.0 * np.power(1.0 + n, 16) - ) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - * np.power(10.0 + n, 2) - ) - + ( - 1 / (1.0 + n) - + ( - 3.0 - * ( - 342192.0 - + 781800.0 * (1.0 + n) - + 723680.0 * np.power(1.0 + n, 2) - + 359100.0 * np.power(1.0 + n, 3) - + 105455.0 * np.power(1.0 + n, 4) - + 18900.0 * np.power(1.0 + n, 5) - + 2030.0 * np.power(1.0 + n, 6) - + 120.0 * np.power(1.0 + n, 7) - + 3.0 * np.power(1.0 + n, 8) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - ) - + S1 - ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 1.0 - * ( - -1.09027627776e11 - - 3.792865824e11 * (1.0 + n) - - 6.0713742384e11 * np.power(1.0 + n, 2) - - 5.9622705312e11 * np.power(1.0 + n, 3) - - 4.03242887656e11 * np.power(1.0 + n, 4) - - 1.99571643e11 * np.power(1.0 + n, 5) - - 7.48814979e10 * np.power(1.0 + n, 6) - - 2.175554084e10 * np.power(1.0 + n, 7) - - 4.951843521e9 * np.power(1.0 + n, 8) - - 8.86903e8 * np.power(1.0 + n, 9) - - 1.2470866e8 * np.power(1.0 + n, 10) - - 1.363476e7 * np.power(1.0 + n, 11) - - 1.137246e6 * np.power(1.0 + n, 12) - - 70000.0 * np.power(1.0 + n, 13) - - 3000.0 * np.power(1.0 + n, 14) - - 80.0 * np.power(1.0 + n, 15) - - 1.0 * np.power(1.0 + n, 16) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - * np.power(10.0 + n, 2) - ) - ) - ) - ) - / (10.0 + n) - + n - * ( - np.power(10.0 + n, -5) - - 0.8224670334241131 / np.power(10.0 + n, 3) - - (0.8224670334241131 * np.power(-1.0, 9.0 + n)) / np.power(10.0 + n, 3) - + 0.419833592426477 / np.power(10.0 + n, 2) - + (1.6218904955860713 * np.power(-1.0, 9.0 + n)) / np.power(10.0 + n, 2) - + (1.2020569031595942 * np.power(-1.0, 10.0 + n)) - / np.power(10.0 + n, 2) - - 0.3382260105347306 / (10.0 + n) - - ( - 0.8224670334241131 - * np.power(-1.0, 9.0 + n) - * ( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1 - ) - ) - / np.power(10.0 + n, 2) - - ( - 0.8224670334241131 - * np.power(-1.0, 10.0 + n) - * ( - Sm1 - - (1.0 * np.power(-1.0, n)) / (1.0 + n) - + ( - 4.0 - * ( - 6396.0 - + 9162.0 * (1.0 + n) - + 5473.0 * np.power(1.0 + n, 2) - + 1719.0 * np.power(1.0 + n, 3) - + 298.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - * np.power(-1.0, n) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - ) - ) - / np.power(10.0 + n, 2) - + ( - np.power(-1.0, 10.0 + n) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3.6831936e7 - + 1.10670624e8 * (1.0 + n) - + 1.4936364e8 * np.power(1.0 + n, 2) - + 1.2041208e8 * np.power(1.0 + n, 3) - + 6.4783246e7 * np.power(1.0 + n, 4) - + 2.454111e7 * np.power(1.0 + n, 5) - + 6.715739e6 * np.power(1.0 + n, 6) - + 1.33785e6 * np.power(1.0 + n, 7) - + 192561.0 * np.power(1.0 + n, 8) - + 19530.0 * np.power(1.0 + n, 9) - + 1325.0 * np.power(1.0 + n, 10) - + 54.0 * np.power(1.0 + n, 11) - + np.power(1.0 + n, 12) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - ) - ) - ) - / np.power(10.0 + n, 3) - + ( - np.power(-1.0, 10.0 + n) - * ( - -1.0 * Sm21 - + Sm3 - + ( - 4.0 - * ( - 1.4760576193536e13 - + 7.3798658489088e13 * (1.0 + n) - + 1.72837443710016e14 * np.power(1.0 + n, 2) - + 2.52453402491616e14 * np.power(1.0 + n, 3) - + 2.5828967175624e14 * np.power(1.0 + n, 4) - + 1.97032446481464e14 * np.power(1.0 + n, 5) - + 1.16425369498108e14 * np.power(1.0 + n, 6) - + 5.4627507667116e13 * np.power(1.0 + n, 7) - + 2.0690074606371e13 * np.power(1.0 + n, 8) - + 6.392775359655e12 * np.power(1.0 + n, 9) - + 1.621160332314e12 * np.power(1.0 + n, 10) - + 3.38175413478e11 * np.power(1.0 + n, 11) - + 5.7948536701e10 * np.power(1.0 + n, 12) - + 8.115008166e9 * np.power(1.0 + n, 13) - + 9.1986012e8 * np.power(1.0 + n, 14) - + 8.3116584e7 * np.power(1.0 + n, 15) - + 5.847213e6 * np.power(1.0 + n, 16) - + 308691.0 * np.power(1.0 + n, 17) - + 11506.0 * np.power(1.0 + n, 18) - + 270.0 * np.power(1.0 + n, 19) - + 3.0 * np.power(1.0 + n, 20) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) - ) - + ( - 2.0 - * ( - -2.3997963958272e13 - - 1.14129905965056e14 * (1.0 + n) - - 2.5222059905856e14 * np.power(1.0 + n, 2) - - 3.44033181492512e14 * np.power(1.0 + n, 3) - - 3.23935732772496e14 * np.power(1.0 + n, 4) - - 2.22502088875352e14 * np.power(1.0 + n, 5) - - 1.14348498644148e14 * np.power(1.0 + n, 6) - - 4.3968646592044e13 * np.power(1.0 + n, 7) - - 1.21438136977e13 * np.power(1.0 + n, 8) - - 2.010931672623e12 * np.power(1.0 + n, 9) - + 4.9482178305e10 * np.power(1.0 + n, 10) - + 1.59991878826e11 * np.power(1.0 + n, 11) - + 6.0723226806e10 * np.power(1.0 + n, 12) - + 1.4651858516e10 * np.power(1.0 + n, 13) - + 2.59766429e9 * np.power(1.0 + n, 14) - + 3.51680472e8 * np.power(1.0 + n, 15) - + 3.6575004e7 * np.power(1.0 + n, 16) - + 2.886025e6 * np.power(1.0 + n, 17) - + 167625.0 * np.power(1.0 + n, 18) - + 6770.0 * np.power(1.0 + n, 19) - + 170.0 * np.power(1.0 + n, 20) - + 2.0 * np.power(1.0 + n, 21) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) - ) - + (S1 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - - ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3.6831936e7 - + 1.10670624e8 * (1.0 + n) - + 1.4936364e8 * np.power(1.0 + n, 2) - + 1.2041208e8 * np.power(1.0 + n, 3) - + 6.4783246e7 * np.power(1.0 + n, 4) - + 2.454111e7 * np.power(1.0 + n, 5) - + 6.715739e6 * np.power(1.0 + n, 6) - + 1.33785e6 * np.power(1.0 + n, 7) - + 192561.0 * np.power(1.0 + n, 8) - + 19530.0 * np.power(1.0 + n, 9) - + 1325.0 * np.power(1.0 + n, 10) - + 54.0 * np.power(1.0 + n, 11) - + np.power(1.0 + n, 12) - ) - * (1 / (1.0 + n) + S1) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - ) - + ( - 1 / (1.0 + n) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3044.0 - + 5886.0 * (1.0 + n) - + 4299.0 * np.power(1.0 + n, 2) - + 1539.0 * np.power(1.0 + n, 3) - + 288.0 * np.power(1.0 + n, 4) - + 27.0 * np.power(1.0 + n, 5) - + np.power(1.0 + n, 6) - ) - ) - / ( - (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - ) - + S1 - ) - * ( - Sm2 - - (1.0 * np.power(-1.0, n)) / np.power(1.0 + n, 2) - + ( - 4.0 - * (9.0 + 2.0 * (1.0 + n)) - * ( - 3.6831936e7 - + 1.10670624e8 * (1.0 + n) - + 1.4936364e8 * np.power(1.0 + n, 2) - + 1.2041208e8 * np.power(1.0 + n, 3) - + 6.4783246e7 * np.power(1.0 + n, 4) - + 2.454111e7 * np.power(1.0 + n, 5) - + 6.715739e6 * np.power(1.0 + n, 6) - + 1.33785e6 * np.power(1.0 + n, 7) - + 192561.0 * np.power(1.0 + n, 8) - + 19530.0 * np.power(1.0 + n, 9) - + 1325.0 * np.power(1.0 + n, 10) - + 54.0 * np.power(1.0 + n, 11) - + np.power(1.0 + n, 12) - ) - * np.power(-1.0, n) - ) - / ( - np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - ) - ) - ) - ) - / np.power(10.0 + n, 2) - ) - ) - ) - - -@nb.njit("c16(c16,c16,c16)", cache=True) -def F13(n, S1, S2): - return ( - -0.15312792746068732 * n - + (0.13621083778040208 * n) / (2.0 + n) - - (0.474631789932249 * n) / (3.0 + n) - + (0.24528438212633397 * n) / (4.0 + n) - - (0.26580874921126374 * n) / (5.0 + n) - + (1.2217722976683179 * n) / (6.0 + n) - - (3.6324293738026023 * n) / (7.0 + n) - + (7.4838836775956015 * n) / (8.0 + n) - - (10.706375063797914 * n) / (9.0 + n) - + (10.449787985527623 * n) / (10.0 + n) - - (6.649468393739114 * n) / (11.0 + n) - + (2.4904695902320904 * n) / (12.0 + n) - - (0.41762920477450316 * n) / (13.0 + n) - - 0.2720646169555415 * (-1.0 + 1 / (1.0 + n)) - - 0.0030864197530864196 - * n - * ( - -49.613452021037574 - + 1695.6636939202713 / (1.0 + n) - + 297.65017554444273 / (2.0 + n) - - 53.043164791285136 / (3.0 + n) - + (280.1816714156928 * (1.0 + (1.0 + n) * S1)) / np.power(1.0 + n, 2) - + (566.2149227313704 * (1.0 + (2.0 + n) * (1 / (1.0 + n) + S1))) - / np.power(2.0 + n, 2) - - ( - 115.5647471869277 - * (1.0 + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) - ) - / np.power(3.0 + n, 2) - - ( - 1607.5136662661575 - * ( - 1.0 - + n - * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) - ) - ) - / np.power(n, 2) - + ( - 972.0 - * ( - 1.0 - + (2.0 + n) * (1 / (1.0 + n) + S1) - + np.power(2.0 + n, 2) - * ( - np.power(1.0 + n, -2) - + S1 / (1.0 + n) - + 0.5 * (np.power(S1, 2) + S2) - ) - ) - ) - / np.power(2.0 + n, 3) - - ( - 1296.0 - * ( - 1.0 - + (1.0 + n) * S1 - + np.power(1.0 + n, 2) - * ( - np.power(1.0 + n, -2) - + S1 / (1.0 + n) - - (1.0 * (1 / (1.0 + n) + S1)) / (1.0 + n) - + 0.5 * (np.power(S1, 2) + S2) - ) - ) - ) - / np.power(1.0 + n, 3) - - ( - 216.0 - * ( - 1.0 - + (3.0 + n) * (1 / (1.0 + n) + 1 / (2.0 + n) + S1) - + np.power(3.0 + n, 2) - * ( - np.power(1.0 + n, -2) - + np.power(2.0 + n, -2) - + S1 / (1.0 + n) - + (1 / (1.0 + n) + S1) / (2.0 + n) - + 0.5 * (np.power(S1, 2) + S2) - ) - ) - ) - / np.power(3.0 + n, 3) - + ( - 540.0 - * ( - 1.0 - + n - * (1 / (1.0 + n) + (1.0 - 2.0 * (1.0 + n)) / (n * (1.0 + n)) + S1) - + np.power(n, 2) - * ( - np.power(1.0 + n, -2) - + 1 / (n * (1.0 + n)) - + S1 / (1.0 + n) - + ((1.0 - 2.0 * (1.0 + n)) * (1 / (1.0 + n) + S1)) - / (n * (1.0 + n)) - + 0.5 * (np.power(S1, 2) + S2) - ) - ) - ) - / np.power(n, 3) - ) - ) - - -@nb.njit("c16(c16,c16,c16,c16)", cache=True) -def F19(n, S1, S2, S3): - return ( - 7.548974594558902 - - 1.5497677311665408 / np.power(1.0 + n, 3) - - 0.5497677311665407 / np.power(2.0 + n, 3) - + 2.0 / np.power(2.0 + n, 2) - - 11.975319856741933 / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) - - (14.370383828090318 * n) / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) - - (4.790127942696773 * np.power(n, 2)) - / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) - + 3.0 / (2.0 + n) - - 9.738329251443808 / ((1.0 + n) * (2.0 + n)) - - (6.492219500962539 * n) / ((1.0 + n) * (2.0 + n)) - - 0.2997677311665407 / np.power(3.0 + n, 3) - - 0.1450639713483865 / np.power(3.0 + n, 2) - - 0.05860975048126964 / (3.0 + n) - - 0.18865662005542957 / np.power(4.0 + n, 3) - - 0.07098989727431243 / np.power(4.0 + n, 2) - - 0.021572713444232602 / (4.0 + n) - - 0.12615662005542957 / np.power(5.0 + n, 3) - - 0.03973989727431243 / np.power(5.0 + n, 2) - - 0.009853963444232604 / (5.0 + n) - - 0.08615662005542958 / np.power(6.0 + n, 3) - - 0.02373989727431243 / np.power(6.0 + n, 2) - - 0.005053963444232604 / (6.0 + n) - - 0.058378842277651805 / np.power(7.0 + n, 3) - - 0.01448063801505317 / np.power(7.0 + n, 2) - - 0.0027391486294177886 / (7.0 + n) - - 0.03797067901234568 / np.power(8.0 + n, 3) - - 0.008649734224965707 / np.power(8.0 + n, 2) - - 0.0014896692458276177 / (8.0 + n) - - 0.02234567901234568 / np.power(9.0 + n, 3) - - 0.004743484224965707 / np.power(9.0 + n, 2) - - 0.0007572473708276177 / (9.0 + n) - - 0.01 / np.power(10.0 + n, 3) - - 0.002 / np.power(10.0 + n, 2) - - 0.0003 / (10.0 + n) - - 3.2461097504812697 * S1 - - 2.3950639713483866 * S2 - - (1.5497677311665408 * S3) / np.power(1.0 + n, 3) - - (4.649303193499622 * n * S3) / np.power(1.0 + n, 3) - - (4.649303193499622 * np.power(n, 2) * S3) / np.power(1.0 + n, 3) - - (1.5497677311665408 * np.power(n, 3) * S3) / np.power(1.0 + n, 3) - ) - - -@nb.njit("c16(c16,c16,c16,c16)", cache=True) -def F21(n, Sm1, Sm2, Sm3): - return 2.3148148148148148e-7 * ( - 2.383072892806571e7 / np.power(-1.0, 1.0 * n) - + 970000.0 / (2.0 + n) - - 922800.0 / np.power(3.0 + n, 3) - - 524120.0 / np.power(3.0 + n, 2) - - 210625.0 / (3.0 + n) - - 1.56e6 / np.power(4.0 + n, 3) - + 1.1232e8 / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) - + (9.36e7 * n) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) - + (2.808e7 * np.power(n, 2)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) - + (3.12e6 * np.power(n, 3)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) - - 1.4e6 / np.power(4.0 + n, 2) - + 2.8e7 / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) - + (1.68e7 * n) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) - + (2.8e6 * np.power(n, 2)) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) - - 172800.0 / np.power(5.0 + n, 3) - - 69120.0 / np.power(5.0 + n, 2) - - 442800.0 / np.power(6.0 + n, 3) - + 7.1131392e9 - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - + (9.6920064e9 * n) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - + (5.632416e9 * np.power(n, 2)) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - + (1.7853696e9 * np.power(n, 3)) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - + (3.241296e8 * np.power(n, 4)) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - + (3.18816e7 * np.power(n, 5)) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - + (1.3284e6 * np.power(n, 6)) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - - 204120.0 / np.power(6.0 + n, 2) - + 1.6003008e8 - / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) - + (1.5676416e8 * n) - / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) - + (5.878656e7 * np.power(n, 2)) - / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) - + (9.79776e6 * np.power(n, 3)) - / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) - + (612360.0 * np.power(n, 4)) - / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) - + 428166.0 / (8.0 + 6.0 * n + np.power(n, 2)) - + (142722.0 * n) / (8.0 + 6.0 * n + np.power(n, 2)) - - 165888.0 / (15.0 + 8.0 * n + np.power(n, 2)) - - (41472.0 * n) / (15.0 + 8.0 * n + np.power(n, 2)) - + (1.4001361e7 * Sm1) / np.power(-1.0, 1.0 * n) - + (1.024412e7 * Sm2) / np.power(-1.0, 1.0 * n) - + (6.3228e6 * Sm3) / np.power(-1.0, 1.0 * n) - + ( - np.power(-1.0, 1.0 - 1.0 * n) - * (3.0568281e7 + 3.8246842e7 * n + 1.4001361e7 * np.power(n, 2)) - * np.power(-1.0, n) - ) - / np.power(1.0 + n, 3) - ) - - -@nb.njit("c16(c16,c16,c16,c16)", cache=True) -def F20(n, Sm1, Sm2, Sm3): - return 2.3148148148148148e-7 * ( - 1.8204889223408133e7 / np.power(-1.0, 1.0 * n) - - 650000.0 / (2.0 + n) - - 382800.0 / np.power(3.0 + n, 3) - - 254120.0 / np.power(3.0 + n, 2) - - 109375.0 / (3.0 + n) - + 600000.0 / np.power(4.0 + n, 3) - - 4.32e7 / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) - - (3.6e7 * n) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) - - (1.08e7 * np.power(n, 2)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) - - (1.2e6 * np.power(n, 3)) / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3)) - + 760000.0 / np.power(4.0 + n, 2) - - 1.52e7 / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) - - (9.12e6 * n) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) - - (1.52e6 * np.power(n, 2)) / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2)) - - 172800.0 / np.power(5.0 + n, 3) - - 69120.0 / np.power(5.0 + n, 2) - + 97200.0 / np.power(6.0 + n, 3) - - 1.5614208e9 - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - - (2.1275136e9 * n) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - - (1.236384e9 * np.power(n, 2)) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - - (3.919104e8 * np.power(n, 3)) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - - (7.11504e7 * np.power(n, 4)) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - - (6.9984e6 * np.power(n, 5)) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - - (291600.0 * np.power(n, 6)) - / (np.power(2.0 + n, 3) * np.power(4.0 + n, 3) * np.power(6.0 + n, 3)) - + 65880.0 / np.power(6.0 + n, 2) - - 5.164992e7 - / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) - - (5.059584e7 * n) - / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) - - (1.897344e7 * np.power(n, 2)) - / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) - - (3.16224e6 * np.power(n, 3)) - / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) - - (197640.0 * np.power(n, 4)) - / (np.power(2.0 + n, 2) * np.power(4.0 + n, 2) * np.power(6.0 + n, 2)) - - 179334.0 / (8.0 + 6.0 * n + np.power(n, 2)) - - (59778.0 * n) / (8.0 + 6.0 * n + np.power(n, 2)) - - 165888.0 / (15.0 + 8.0 * n + np.power(n, 2)) - - (41472.0 * n) / (15.0 + 8.0 * n + np.power(n, 2)) - + (1.2280111e7 * Sm1) / np.power(-1.0, 1.0 * n) - + (7.81412e6 * Sm2) / np.power(-1.0, 1.0 * n) - + (3.6228e6 * Sm3) / np.power(-1.0, 1.0 * n) - + ( - np.power(-1.0, 1.0 - 1.0 * n) - * (2.3717031e7 + 3.2374342e7 * n + 1.2280111e7 * np.power(n, 2)) - * np.power(-1.0, n) - ) - / np.power(1.0 + n, 3) ) diff --git a/src/eko/matching_conditions/n3lo/s_functions.py b/src/eko/matching_conditions/n3lo/s_functions.py index 878da94e7..1bcb2594f 100644 --- a/src/eko/matching_conditions/n3lo/s_functions.py +++ b/src/eko/matching_conditions/n3lo/s_functions.py @@ -118,7 +118,7 @@ def harmonic_Sm211(N, Sm1): ) -@nb.njit("c16(c16,c16)", cache=True) +@nb.njit("c16(c16,c16,c16,c16)", cache=True) def harmonic_Sm2m1(N, S1, S2, Sm2): return -gf.mellin_g19(N, S1) + log2 * (S2 - Sm2) - 5 / 8 * zeta3 @@ -159,10 +159,10 @@ def harmonic_S221(N, S1, S2, S21): ) -@nb.njit("c16(c16,c16,c16,c16,c16,c16)", cache=True) -def harmonic_Sm221(N, S1, S2, Sm1, S21, Sm21): +@nb.njit("c16(c16,c16,c16,c16,c16)", cache=True) +def harmonic_Sm221(N, S1, Sm1, S21, Sm21): return ( - (-1) ** (N + 1) * (2 * f.F12(N, S1, S2) - 1 / 2 * f.F14(N, S1, S2, S21)) + (-1) ** (N + 1) * (f.F14F12(N,S1,S21)) + zeta2 * Sm21 - 3 / 10 * zeta2 ** 2 * Sm1 - 0.119102 @@ -170,7 +170,7 @@ def harmonic_Sm221(N, S1, S2, Sm1, S21, Sm21): ) -@nb.njit("c16(c16,c16,c16,c16,c16,c16,c16)", cache=True) +@nb.njit("c16(c16,c16,c16,c16,c16,c16,c16,c16,c16)", cache=True) def harmonic_S21m2(N, S1, S2, Sm1, Sm2, Sm3, S21, Sm21, S2m1): return ( (-1) ** (N) * f.F16(N, S1, Sm1, Sm2, Sm3, Sm21) diff --git a/tests/test_f_functions.py b/tests/test_f_functions.py index 8d051c22f..a08b5b339 100644 --- a/tests/test_f_functions.py +++ b/tests/test_f_functions.py @@ -90,7 +90,7 @@ def test_F12_F14(): Sm1 = sf.harmonic_Sm1(N) S21 = sf.harmonic_S21(N, S1, S2) Sm21 = sf.harmonic_Sm21(N, Sm1) - Sm221 = sf.harmonic_Sm221(N, S1, S2, Sm1, S21, Sm21) + Sm221 = sf.harmonic_Sm221(N, S1, Sm1, S21, Sm21) np.testing.assert_allclose(Sm221, vals, atol=1e-05) diff --git a/tests/test_g_functions.py b/tests/test_g_functions.py index 41014d646..33a2c9f47 100644 --- a/tests/test_g_functions.py +++ b/tests/test_g_functions.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Test G functions impleeted by muselli PhD +# Test G functions implemented by muselli PhD import numpy as np From f6e1d7be1be956abc21d217f48bff563a7c4d6e8 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 28 Sep 2021 14:10:02 +0200 Subject: [PATCH 34/71] Adding other harmonics --- .../matching_conditions/n3lo/cs_functions.py | 1427 +++++++++++++++++ .../matching_conditions/n3lo/f_functions.py | 7 +- .../matching_conditions/n3lo/h_functions.py | 405 +++++ tests/test_cs_functions.py | 311 ++++ 4 files changed, 2149 insertions(+), 1 deletion(-) create mode 100644 src/eko/matching_conditions/n3lo/cs_functions.py create mode 100644 src/eko/matching_conditions/n3lo/h_functions.py create mode 100644 tests/test_cs_functions.py diff --git a/src/eko/matching_conditions/n3lo/cs_functions.py b/src/eko/matching_conditions/n3lo/cs_functions.py new file mode 100644 index 000000000..fdfdb8a0b --- /dev/null +++ b/src/eko/matching_conditions/n3lo/cs_functions.py @@ -0,0 +1,1427 @@ +# -*- coding: utf-8 -*- +"""This module contains some approximations for generalized harmonics sum""" +import numba as nb +import numpy as np +import mpmath as mp +from ...anomalous_dimensions.harmonics import zeta2, zeta3 + +ln2 = np.log(2) + +# @nb.njit("c16(c16)", cache=True) +def S111l211(H24): + return complex(H24) + + +# @nb.njit("c16(c16,c16)", cache=True) +def S1111l20511(n, S1): + return complex( + -1.9723041257941845 + - 0.08333333333333336 / (4.0 + n) + + 36.70520952439886 / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n)) + + (51.3872933341584 * n) / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n)) + + (22.023125714639317 * np.power(n, 2)) + / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n)) + + (2.9364167619519086 * np.power(n, 3)) + / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n)) + + 0.5570208571546438 / (5.0 + n) + + 0.47368752382131046 / (6.0 + n) + + 0.404243079376866 / (7.0 + n) + + 0.3472986349324216 / (8.0 + n) + + 0.3005104404879771 / (9.0 + n) + + 0.26170973502060496 / (10.0 + n) + + 0.22915021121108117 / (11.0 + n) + + 0.20149148105235104 / (12.0 + n) + + 0.1777199863433563 / (13.0 + n) + + 0.15706943319280317 / (14.0 + n) + + 0.13895637231188515 / (15.0 + n) + + 0.12293186353142399 / (16.0 + n) + + 0.10864628686024465 / (17.0 + n) + + 0.09582397689507753 / (18.0 + n) + + 0.08424493020690386 / (19.0 + n) + + 0.07373153305835264 / (20.0 + n) + + 0.06413884299411146 / (21.0 + n) + + 0.05534739575263509 / (22.0 + n) + + 0.047257820113419974 / (23.0 + n) + + 0.03978675952632231 / (24.0 + n) + + 0.03286374838430062 / (25.0 + n) + + 0.02642879344355784 / (26.0 + n) + + 0.02043048189300573 / (27.0 + n) + + 0.014824487031234552 / (28.0 + n) + + 0.009572377262420904 / (29.0 + n) + + 0.004640658782124118 / (30.0 + n) + + 0.7341041904879771 * S1 + + 0.9015426773696957 * n * mp.hyper([1.0, 1.0, 1.0 - 1.0 * n], [2.0, 2.0], -1.0) + ) + + +# @nb.njit("c16(c16)", cache=True) +def S1l05(n): + return complex(ln2 - 1.0 * mp.betainc(1.0 + n, 0.0, x2=0.5)) + + +# @nb.njit("c16(c16,c16,c16, c16,c16)", cache=True) +def S121l2105(n, S1, S2, H23, H25): + return complex( + 0.041666666666666664 + * ( + 8.718466787621855 + - 13.9737726351603 * H23 + - 33.27106466687737 * H25 + + 2.9999999999999996 / (3.0 + n) + + 4.249999999999999 / (4.0 + n) + + 4.760416666666666 / (5.0 + n) + + 4.973958333333333 / (6.0 + n) + + 5.065434027777777 / (7.0 + n) + + 5.105381944444444 / (8.0 + n) + + 5.137736900800947 * S1 + - 5.123098316149376 + * ( + ( + 4.0 + * (9.0 + 2.0 * n) + * ( + 3044.0 + + 5886.0 * n + + 4299.0 * np.power(n, 2) + + 1539.0 * np.power(n, 3) + + 288.0 * np.power(n, 4) + + 27.0 * np.power(n, 5) + + np.power(n, 6) + ) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + S1 + ) + + ( + -4.508315233733057e-9 + - 2.0075627335735142e7 * S1 + + np.power(n, 4) + * ( + 8.34080933039605e8 + - 5.27949188465133e8 * S1 + - 6.269810033052008e8 * S2 + ) + + np.power(n, 3) + * ( + 6.68725912090791e8 + - 4.985280158146429e8 * S1 + - 5.920410569053438e8 * S2 + ) + + np.power(n, 5) + * ( + 6.970075838123745e8 + - 3.955620440258531e8 * S1 + - 4.6976090247208434e8 * S2 + ) + + np.power(n, 2) + * ( + 3.220716119130001e8 + - 3.1445681939854693e8 * S1 + - 3.7344209713788414e8 * S2 + ) + + np.power(n, 6) + * ( + 4.1200442264028406e8 + - 2.1646696206675032e8 * S1 + - 2.5707146828582215e8 * S2 + ) + + n + * ( + 7.04043541297633e7 + - 1.1844620128083734e8 * S1 + - 1.4066413916204685e8 * S2 + ) + + np.power(n, 7) + * ( + 1.7720686833255962e8 + - 8.798070100233266e7 * S1 + - 1.0448397192598484e8 * S2 + ) + + np.power(n, 8) + * ( + 5.615076052598522e7 + - 2.671201824728946e7 * S1 + - 3.1722613400888775e7 * S2 + ) + + np.power(n, 9) + * ( + 1.3108506526779806e7 + - 6.03389941621764e6 * S1 + - 7.165728052014327e6 * S2 + ) + + np.power(n, 10) + * ( + 2.227101326786286e6 + - 999008.3708972329 * S1 + - 1.1864006695727834e6 * S2 + ) + + np.power(n, 11) + * ( + 267716.88479469996 + - 117649.99198681205 * S1 + - 139718.5782768029 * S2 + ) + + np.power(n, 12) + * (21568.39562370471 - 9323.316514425609 * S1 - 11072.168439809184 * S2) + + np.power(n, 13) + * (1044.148599842857 - 445.3505292456677 * S1 - 528.8886274467523 * S2) + + np.power(n, 14) + * (22.94882997174772 - 9.681533244471037 * S1 - 11.497578857538095 * S2) + - 2.384137951899099e7 * S2 + ) + / ( + np.power(1.0 + n, 2) + * np.power(2.0 + n, 4) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + (complex(0.0, 16.14067650363345) * np.cos(3.141592653589793 * n)) + / np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) + + ( + 16.14067650363345 + * np.cos(3.141592653589793 * n) + * 1 + / np.tan(3.141592653589793 * n) + ) + / np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) + + ( + 3.2349177543783325 + * np.power(2.0, n) + * np.cos(3.141592653589793 * n) + * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) + ) + / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) + - ( + 0.33302465198892944 + * np.power(2.0, 1.0 + n) + * np.cos(3.141592653589793 * n) + * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) + ) + / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) + + ( + complex(0.0, 3.2349177543783325) + * np.power(2.0, n) + * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) + * np.sin(3.141592653589793 * n) + ) + / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) + - ( + complex(0.0, 0.33302465198892944) + * np.power(2.0, 1.0 + n) + * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) + * np.sin(3.141592653589793 * n) + ) + / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) + ) + ) + + +# @nb.njit("c16(c16,c16,c16,c16,c16)", cache=True) +def S112l2105(n, S1, S2, H21, H23): + return complex( + 0.020833333333333332 + * ( + -27.9475452703206 * (H21 + H23) + - 14.823618004648024 * S1 + + ( + -0.9260288995236766 + + 1.75595385252132e15 * S1 + + 1.3651603815024e15 * S2 + + np.power(n, 22) + * ( + -40.27318148695487 + + 14.816462392378826 * S1 + + 11.519008556547618 * S2 + ) + + np.power(n, 21) + * ( + -4632.295480386484 + + 1718.7096375159438 * S1 + + 1336.2049925595238 * S2 + ) + + np.power(n, 20) + * (-250567.9539452148 + 93847.47279332748 * S1 + 72961.40019717262 * S2) + + np.power(n, 19) + * ( + -8.474231929409903e6 + + 3.207467778702168e6 * S1 + + 2.4936349723214284e6 * S2 + ) + + np.power(n, 18) + * ( + -2.0095959944770676e8 + + 7.696309156130673e7 * S1 + + 5.98346951353962e7 * S2 + ) + + np.power(n, 17) + * ( + -3.5519950582077947e9 + + 1.3784542606770802e9 * S1 + + 1.0716746010651115e9 * S2 + ) + + np.power(n, 16) + * ( + -4.8556219898933846e10 + + 1.912722298960369e10 * S1 + + 1.4870394797719671e10 * S2 + ) + + np.power(n, 15) + * ( + -5.257581875674014e11 + + 2.106450745096599e11 * S1 + + 1.6376530047546756e11 * S2 + ) + + np.power(n, 14) + * ( + -4.580741130988878e12 + + 1.8710790245760586e12 * S1 + + 1.4546640569988308e12 * S2 + ) + + np.power(n, 13) + * ( + -3.244334123292615e13 + + 1.3549062415003168e13 * S1 + + 1.0533672732291225e13 * S2 + ) + + np.power(n, 12) + * ( + -1.8792319567508488e14 + + 8.051686163954172e13 * S1 + + 6.259756165880115e13 * S2 + ) + + np.power(n, 11) + * ( + -8.925629770015451e14 + + 3.94003621424455e14 * S1 + + 3.063167823942602e14 * S2 + ) + + np.power(n, 10) + * ( + -3.474511315485193e15 + + 1.5885028238122522e15 * S1 + + 1.2349761457907358e15 * S2 + ) + + np.power(n, 9) + * ( + -1.1045643145500984e16 + + 5.265033861267008e15 * S1 + + 4.093282761588436e15 * S2 + ) + + n + * ( + -5.427466825742352e15 + + 1.145690208061728e16 * S1 + + 8.907129758993039e15 * S2 + ) + + np.power(n, 8) + * ( + -2.8476622260833744e16 + + 1.4273882811710074e16 * S1 + + 1.1097181897334674e16 * S2 + ) + + np.power(n, 7) + * ( + -5.887543943227375e16 + + 3.1389184218177224e16 * S1 + + 2.440341506743307e16 * S2 + ) + + np.power(n, 2) + * ( + -2.9025585004552024e16 + + 3.4459443241488012e16 * S1 + + 2.6790377557111176e16 * S2 + ) + + np.power(n, 6) + * ( + -9.599855549416707e16 + + 5.529627361997772e16 * S1 + + 4.298990083498981e16 * S2 + ) + + np.power(n, 3) + * ( + -7.2360160718216e16 + + 6.370427756808302e16 * S1 + + 4.95266750565833e16 * S2 + ) + + np.power(n, 5) + * ( + -1.2041907301754731e17 + + 7.66394296991267e16 * S1 + + 5.958306531573035e16 * S2 + ) + + np.power(n, 4) + * ( + -1.118794246274288e17 + + 8.14061286433952e16 * S1 + + 6.328891928217773e16 * S2 + ) + ) + / ( + np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + * np.power(3.0 + n, 4) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + ) + + ( + 13.9737726351603 + * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) + * ( + 2.0 + * ( + -0.6931471805599453 * np.power(2.0, n) + + H23 * n + + 0.6931471805599453 * n * S1 + + 2.177586090303602 * n * 1 / np.tan(3.141592653589793 * n) + ) + + 0.6931471805599453 + * np.power(2.0, n) + * n + * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n) + ) + * np.sin(3.141592653589793 * n) + ) + / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) + - ( + 7.411809002324012 + * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) + * ( + 6.283185307179586 * n * np.cos(3.141592653589793 * n) + + np.power(2.0, n) + * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) + * np.sin(3.141592653589793 * n) + ) + ) + / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) + ) + ) + + +# @nb.njit("c16(c16,c16,c16)", cache=True) +def S211l2105(n, S1, S2): + return complex( + 0.041666666666666664 + * ( + complex(26.40764917447151, 30.42909291939018) + - (19.351524467966858 * np.power(2.0, n)) / (1.0 + n) + - (6.262726309306497 * np.power(2.0, n)) / (2.0 + n) + - 0.7343749999999999 / (3.0 + n) + + (12.00212909720108 * np.power(2.0, n)) / (3.0 + n) + - 0.23437499999999994 / (4.0 + n) + - (172.2163955321142 * np.power(2.0, n)) / (4.0 + n) + - 0.0625 / (5.0 + n) + + (1405.5398464455116 * np.power(2.0, n)) / (5.0 + n) + - (8703.997977574893 * np.power(2.0, n)) / (6.0 + n) + + (41928.01774475129 * np.power(2.0, n)) / (7.0 + n) + - (160951.91817594544 * np.power(2.0, n)) / (8.0 + n) + + (499634.153549029 * np.power(2.0, n)) / (9.0 + n) + - (1.2654327397059284e6 * np.power(2.0, n)) / (10.0 + n) + + (2.6260030398488953e6 * np.power(2.0, n)) / (11.0 + n) + - (4.465586330056064e6 * np.power(2.0, n)) / (12.0 + n) + + (6.198176978342689e6 * np.power(2.0, n)) / (13.0 + n) + - (6.961720352934347e6 * np.power(2.0, n)) / (14.0 + n) + + (6.236645257147073e6 * np.power(2.0, n)) / (15.0 + n) + - (4.355777195115037e6 * np.power(2.0, n)) / (16.0 + n) + + (2.287718942232814e6 * np.power(2.0, n)) / (17.0 + n) + - (850756.7344439693 * np.power(2.0, n)) / (18.0 + n) + + (199917.59252552615 * np.power(2.0, n)) / (19.0 + n) + - (22348.960043583 * np.power(2.0, n)) / (20.0 + n) + - 7.411809002324012 * S1 + - 2.234375 + * ( + -0.5772156649015329 + - 1.0 / (3.0 + n) + + (11.0 + 12.0 * n + 3.0 * np.power(n, 2)) + / (6.0 + 11.0 * n + 6.0 * np.power(n, 2) + np.power(n, 3)) + + S1 + ) + + ( + 2301.0054569785552 + + 2.3564799588509725e19 * S1 + + np.power(n, 21) * (-10.512601395041514 + 9.685881103847077 * S1) + + np.power(n, 20) * (-2206.628022019722 + 2043.7209129117334 * S1) + + np.power(n, 19) * (-216505.99319159146 + 201708.47398761538 * S1) + + np.power(n, 18) * (-1.3192300150519693e7 + 1.2373374104326006e7 * S1) + + np.power(n, 17) * (-5.593867445718834e8 + 5.287018441337475e8 * S1) + + np.power(n, 16) * (-1.752878291455452e10 + 1.6714041339232273e10 * S1) + + np.power(n, 15) * (-4.207344725909635e11 + 4.05296516933841e11 * S1) + + np.power(n, 14) * (-7.911700211293982e12 + 7.712702038095058e12 * S1) + + np.power(n, 13) * (-1.182221056152559e14 + 1.168736012631931e14 * S1) + + np.power(n, 12) + * (-1.4155108114396065e15 + 1.4228119592370445e15 * S1) + + np.power(n, 11) * (-1.363175581264904e16 + 1.3977890612219908e16 * S1) + + np.power(n, 10) * (-1.0556974421987099e17 + 1.109017392681198e17 * S1) + + np.power(n, 9) * (-6.548610450489597e17 + 7.087460624896044e17 * S1) + + np.power(n, 8) * (-3.227614926711552e18 + 3.6260496031614787e18 * S1) + + np.power(n, 7) * (-1.2477695102045143e19 + 1.4702987812923677e19 * S1) + + np.power(n, 6) * (-3.711573495044675e19 + 4.655642074876013e19 * S1) + + n * (-2.4500394557497614e19 + 1.0834481358073427e20 * S1) + + np.power(n, 5) * (-8.257880390369016e19 + 1.1272226323636158e20 * S1) + + np.power(n, 4) * (-1.3168723078804224e20 + 2.025195993855592e20 * S1) + + np.power(n, 2) * (-8.864030957300654e19 + 2.184815897520579e20 * S1) + + np.power(n, 3) * (-1.4055237841498638e20 + 2.583678854961562e20 * S1) + ) + / ( + np.power(1.0 + n, 2) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + * (16.0 + n) + * (17.0 + n) + * (18.0 + n) + * (19.0 + n) + * (20.0 + n) + ) + + 5.765436167018416 * S2 + - 4.528162976761489 + * ( + 9.42477796076938 + + 1 + / np.tan(3.141592653589793 * n) + * ( + 2.772588722239781 + + 12.566370614359172 * 1 / np.tan(3.141592653589793 * n) + ) + ) + + 1.441359041754604 + * np.power(2.0, 2.0 + n) + * mp.lerchphi(0.5, 2.0, -1.0 * n) + - 2.882718083509208 + * ( + -3.141592653589793 + * ( + 9.42477796076938 + + 1 + / np.tan(3.141592653589793 * n) + * ( + 2.772588722239781 + + 12.566370614359172 * 1 / np.tan(3.141592653589793 * n) + ) + ) + + np.power(2.0, 2.0 + n) * mp.lerchphi(0.5, 2.0, -1.0 * n) + ) + + ( + 19.371762207694154 + * np.power(2.0, n) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / (1.0 + n) + + 27.36435385542846 + * ( + S1 + + n * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) + ) + ) + ) + + +# @nb.njit("c16(c16)", cache=True) +def S12l21(H25): + return complex(-2.0 * H25) + + +# @nb.njit("c16(c16,c16,c16,c16)", cache=True) +def S13l205(n, S1, S2, S3): + return complex( + 0.020833333333333332 + * ( + -35.91351656957576 + - 24.94558274872449 / np.power(2.0 + n, 2) + + 0.1875 / np.power(4.0 + n, 2) + + 0.046875 / (4.0 + n) + + 0.020833333333333332 / np.power(6.0 + n, 2) + + 0.003472222222222222 / (6.0 + n) + + 0.0029296875 / np.power(8.0 + n, 2) + + 0.0003662109375 / (8.0 + n) + + 1.5 / (2.0 + 1.0 * n) + + (27.94558274872449 * (5.0 + 6.0 * n + 2.0 * np.power(n, 2))) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + 0.8541666666666666 * (np.power(2.0 + n, -2) + np.power(3.0 + n, -2)) + + 0.2690972222222222 * (1 / (2.0 + n) + 1 / (3.0 + n)) + + 0.09141608205782313 + * ( + np.power(2.0 + n, -2) + + np.power(3.0 + n, -2) + + np.power(4.0 + n, -2) + + np.power(5.0 + n, -2) + ) + + 0.016931727620363622 + * (1 / (2.0 + n) + 1 / (3.0 + n) + 1 / (4.0 + n) + 1 / (5.0 + n)) + + 0.010582748724489796 * (np.power(6.0 + n, -2) + np.power(7.0 + n, -2)) + + 0.0014595053981413995 * (1 / (6.0 + n) + 1 / (7.0 + n)) + - 25.78623329318593 * S1 + + 25.786028949842585 + * ( + -0.5772156649015329 + - 1.0 / (2.0 + n) + + (3.0 + 2.0 * n) / (2.0 + 3.0 * n + np.power(n, 2)) + + S1 + ) + + 27.94558274872449 * S2 + - ( + 6.0 + * ( + -9.0 + - 15.0 * n + - 9.0 * np.power(n, 2) + - 2.0 * np.power(n, 3) + - 1.0 + * np.power(2.0 + 3.0 * n + np.power(n, 2), 3) + * (-1.2020569031595945 + S3) + ) + ) + / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - ( + 2.0 + * ( + -251.0 + - 684.0 * n + - 795.0 * np.power(n, 2) + - 504.0 * np.power(n, 3) + - 183.0 * np.power(n, 4) + - 36.0 * np.power(n, 5) + - 3.0 * np.power(n, 6) + - 1.0 + * np.power( + 6.0 + 11.0 * n + 6.0 * np.power(n, 2) + np.power(n, 3), 3 + ) + * (-1.2020569031595945 + S3) + ) + ) + / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) + + ( + 0.375 + * ( + 32560.0 + + 114024.0 * n + + 179100.0 * np.power(n, 2) + + 165380.0 * np.power(n, 3) + + 98700.0 * np.power(n, 4) + + 39396.0 * np.power(n, 5) + + 10500.0 * np.power(n, 6) + + 1800.0 * np.power(n, 7) + + 180.0 * np.power(n, 8) + + 8.0 * np.power(n, 9) + + 2.0 + * np.power( + 24.0 + + 50.0 * n + + 35.0 * np.power(n, 2) + + 10.0 * np.power(n, 3) + + np.power(n, 4), + 3, + ) + * (-1.2020569031595945 + S3) + ) + ) + / ( + np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + ) + + 0.30000000000000004 + * ( + -1.0 / np.power(6.0 + n, 3) + + ( + (7.0 + 2.0 * n) + * ( + 6.3467712e7 + + 2.75413824e8 * n + + 5.54256432e8 * np.power(n, 2) + + 6.84826352e8 * np.power(n, 3) + + 5.79544028e8 * np.power(n, 4) + + 3.54873092e8 * np.power(n, 5) + + 1.61970683e8 * np.power(n, 6) + + 5.5932611e7 * np.power(n, 7) + + 1.4676674e7 * np.power(n, 8) + + 2.911041e6 * np.power(n, 9) + + 429534.0 * np.power(n, 10) + + 45717.0 * np.power(n, 11) + + 3318.0 * np.power(n, 12) + + 147.0 * np.power(n, 13) + + 3.0 * np.power(n, 14) + ) + ) + / ( + np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + ) + + S3 + ) + + ( + -4.849365675830262 + + 24.0 * S3 + + np.power(n, 3) * (-28.849365675830263 + 24.0 * S3) + + n * (-86.5480970274908 + 72.0 * S3) + + np.power(n, 2) * (-86.5480970274908 + 72.0 * S3) + ) + / np.power(1.0 + n, 3) + + ( + -1.8827917371821213e8 + + np.power(n, 21) * (-0.15025711289494928 + 0.125 * S3) + + 1.6003008e10 * S3 + + np.power(n, 20) * (-12.621597483175739 + 10.5 * S3) + + np.power(n, 19) * (-498.5531005854417 + 414.75 * S3) + + np.power(n, 18) * (-12309.514745257404 + 10241.0 * S3) + + np.power(n, 17) * (-213006.90671411887 + 177247.875 * S3) + + np.power(n, 16) * (-2.745208063810683e6 + 2.2853355e6 * S3) + + np.power(n, 15) * (-2.7333790694426738e7 + 2.2772873e7 * S3) + + np.power(n, 14) * (-2.1525719333960438e8 + 1.79575452e8 * S3) + + np.power(n, 13) * (-1.3613819668701482e9 + 1.138062751875e9 * S3) + + np.power(n, 12) * (-6.981325709004752e9 + 5.8543813055e9 * S3) + + np.power(n, 11) * (-2.918265095349929e10 + 2.458519389375e10 * S3) + + np.power(n, 10) * (-9.959730967499185e10 + 8.4473879133e10 * S3) + + n * (-5.3368228689679504e10 + 1.244805408e11 * S3) + + np.power(n, 9) * (-2.7702671731906366e11 + 2.37268950102125e11 * S3) + + np.power(n, 2) * (-3.0945500345609973e11 + 4.4785043856e11 * S3) + + np.power(n, 8) * (-6.245882034204874e11 + 5.425955373405e11 * S3) + + np.power(n, 3) * (-8.52658888324106e11 + 9.92117796984e11 * S3) + + np.power(n, 7) * (-1.1304998617813767e12 + 1.0026916293345e12 * S3) + + np.power(n, 6) * (-1.6179236885848447e12 + 1.479872994614e12 * S3) + + np.power(n, 4) * (-1.4740504277291758e12 + 1.519937938008e12 * S3) + + np.power(n, 5) * (-1.7889236321409622e12 + 1.714464923598e12 * S3) + ) + / ( + np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + ) + + ( + -3.1076170690167686e10 + + np.power(n, 24) * (-0.06439590552640682 + 0.05357142857142857 * S3) + + 3.511517184e12 * S3 + + np.power(n, 23) * (-6.954757796851938 + 5.785714285714286 * S3) + + np.power(n, 22) * (-355.85177393892417 + 296.0357142857143 * S3) + + np.power(n, 21) * (-11474.975364805698 + 9546.42857142857 * S3) + + np.power(n, 20) * (-261689.50235318032 + 217731.375 * S3) + + np.power(n, 19) * (-4.489549647230873e6 + 3.7362465e6 * S3) + + np.power(n, 18) * (-6.0174545299099594e7 + 5.009824671428571e7 * S3) + + np.power(n, 17) * (-6.459454766764826e8 + 5.381398851428571e8 * S3) + + np.power(n, 16) * (-5.647936378402138e9 + 4.710152996517857e9 * S3) + + np.power(n, 15) * (-4.06934872365595e10 + 3.3988322190214283e10 * S3) + + np.power(n, 14) * (-2.434761228276682e11 + 2.0380329643275e11 * S3) + + np.power(n, 13) * (-1.2154258996820479e12 + 1.020534802371e12 * S3) + + np.power(n, 12) * (-5.07315542830191e12 + 4.2781896451329106e12 * S3) + + np.power(n, 11) * (-1.770226596040418e13 + 1.5018709031540355e13 * S3) + + n * (-1.1646920948258486e13 + 2.86314061824e13 * S3) + + np.power(n, 10) * (-5.151048207445098e13 + 4.407053531194735e13 * S3) + + np.power(n, 9) * (-1.2436603267566345e14 + 1.0765907902298828e14 * S3) + + np.power(n, 2) * (-7.201432181343031e13 + 1.0867875452928e14 * S3) + + np.power(n, 8) * (-2.4716507853081303e14 + 2.17524482033526e14 * S3) + + np.power(n, 3) * (-2.1249044478604434e14 + 2.5583791381994056e14 * S3) + + np.power(n, 7) * (-3.99629094081214e14 + 3.60077496552648e14 * S3) + + np.power(n, 4) * (-3.9587554959384794e14 + 4.198147424345417e14 * S3) + + np.power(n, 6) * (-5.168531019972349e14 + 4.8186122866386856e14 * S3) + + np.power(n, 5) * (-5.216872802515547e14 + 5.116683439482377e14 * S3) + ) + / ( + np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + ) + + ( + -7.7239450334953125e12 + + np.power(n, 27) * (-0.02817320866780299 + 0.0234375 * S3) + + 1.119954511872e15 * S3 + + np.power(n, 26) * (-3.8033831701534035 + 3.1640625 * S3) + + np.power(n, 25) * (-244.68431727986894 + 203.5546875 * S3) + + np.power(n, 24) * (-9983.693321652685 + 8305.6640625 * S3) + + np.power(n, 23) * (-290084.326995499 + 241342.2421875 * S3) + + np.power(n, 22) * (-6.3886763936445005e6 + 5.3158812890625e6 * S3) + + np.power(n, 21) * (-1.1083531859904346e8 + 9.22446755859375e7 * S3) + + np.power(n, 20) * (-1.5540653936148872e9 + 1.2938741455078125e9 * S3) + + np.power(n, 19) + * (-1.7928546082039547e10 + 1.4935168301132812e10 * S3) + + np.power(n, 18) + * (-1.7235833156872174e11 + 1.4369777933027344e11 * S3) + + np.power(n, 17) * (-1.3933977821809019e12 + 1.163032128121289e12 * S3) + + np.power(n, 16) * (-9.532903149222146e12 + 7.969538339323242e12 * S3) + + np.power(n, 15) * (-5.5421804520716875e13 + 4.643376378330129e13 * S3) + + np.power(n, 14) + * (-2.7442937550584856e14 + 2.3060292041751853e14 * S3) + + np.power(n, 13) * (-1.1580659863189835e15 + 9.770012148134408e14 * S3) + + np.power(n, 12) * (-4.1604768475468305e15 + 3.528835659305147e15 * S3) + + n * (-3.7001995643590905e15 + 9.5049472799232e15 * S3) + + np.power(n, 11) + * (-1.2690820817593494e16 + 1.0842168128947024e16 * S3) + + np.power(n, 10) + * (-3.2719471459776132e16 + 2.8228294043448464e16 * S3) + + np.power(n, 2) * (-2.4139679917260076e16 + 3.774708643918464e16 * S3) + + np.power(n, 9) * (-7.082596355241246e16 + 6.192631872765216e16 * S3) + + np.power(n, 3) * (-7.540813820098134e16 + 9.348995950413898e16 * S3) + + np.power(n, 8) * (-1.2752168126680246e17 + 1.135732940048904e17 * S3) + + np.power(n, 4) * (-1.4945046274726707e17 + 1.62389726656281e17 * S3) + + np.power(n, 7) * (-1.8852682955808618e17 + 1.7229783969179136e17 * S3) + + np.power(n, 5) * (-2.107050012914055e17 + 2.108914095651679e17 * S3) + + np.power(n, 6) * (-2.2478668354322694e17 + 2.1315134716528384e17 * S3) + ) + / ( + np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + - ( + 12.893116646592965 + * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) + * ( + 6.283185307179586 * n * np.cos(3.141592653589793 * n) + + np.power(2.0, n) + * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) + * np.sin(3.141592653589793 * n) + ) + ) + / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) + ) + ) + + +def S31l205(n, S1, S2, S3): + # HarmonicNumber[5. +N] + Snp5 = (274 + 450 * n + 255 * n ** 2 + 60 * n ** 3 + 5 * n ** 4) / ( + (1 + n) * (2 + n) * (3 + n) * (4 + n) * (5 + n) + ) + S1 + # Mellin[PolyLog[3,x/2]/(-1+x)] + H26 = ( + -0.557968 + + 1 / (-4 - 2 * n) + - 0.53125 / (3 + n) + - 0.53588 / (4 + n) + - 0.536856 / (5 + n) + + 0.537106 * Snp5 + ) + return ( + H26 + - 1.0 / 6.0 * ln2 ** 3 * S1 + + 1.0 / 2.0 * ln2 * zeta2 * S1 + - 7.0 / 8.0 * zeta3 * S1 + - 1.0 / 2.0 * ln2 ** 2 * S2 + + 1.0 / 2.0 * zeta2 * S2 + - ln2 * S3 + + ln2 * S3l2(n) + ) + + +# @nb.njit("c16(c16,c16,c16)", cache=True) +def S121l2051(n, S1, H23): + return complex( + ( + -1.0830401704283533e13 * H23 + + 4.3924567500723857e12 * n + - 4.719820298271499e13 * H23 * n + + 1.5347099809768277e13 * np.power(n, 2) + - 9.28277799319932e13 * H23 * np.power(n, 2) + + 2.4643473394818945e13 * np.power(n, 3) + - 1.1033270798041445e14 * H23 * np.power(n, 3) + + 2.4206702804354082e13 * np.power(n, 4) + - 8.928723061726825e13 * H23 * np.power(n, 4) + + 1.6319435638160908e13 * np.power(n, 5) + - 5.244803302936807e13 * H23 * np.power(n, 5) + + 8.024831718581373e12 * np.power(n, 6) + - 2.324477933964049e13 * H23 * np.power(n, 6) + + 2.9839764042451226e12 * np.power(n, 7) + - 7.966230808118927e12 * H23 * np.power(n, 7) + + 8.578892089462283e11 * np.power(n, 8) + - 2.1441872369411062e12 * H23 * np.power(n, 8) + + 1.9323035163842896e11 * np.power(n, 9) + - 4.573731355009803e11 * H23 * np.power(n, 9) + + 3.4319246716192318e10 * np.power(n, 10) + - 7.760339042151804e10 * H23 * np.power(n, 10) + + 4.809688527205751e9 * np.power(n, 11) + - 1.0460546339529638e10 * H23 * np.power(n, 11) + + 5.291841901984562e8 * np.power(n, 12) + - 1.1129708511703498e9 * H23 * np.power(n, 12) + + 4.517523002879353e7 * np.power(n, 13) + - 9.228190983574654e7 * H23 * np.power(n, 13) + + 2.930975307090889e6 * np.power(n, 14) + - 5.836196460364303e6 * H23 * np.power(n, 14) + + 139635.45571358403 * np.power(n, 15) + - 271841.80388733785 * H23 * np.power(n, 15) + + 4605.037890010919 * np.power(n, 16) + - 8787.237785103225 * H23 * np.power(n, 16) + + 93.90370458786407 * np.power(n, 17) + - 176.00794515276021 * H23 * np.power(n, 17) + + 0.8918045027331737 * np.power(n, 18) + - 1.6449340668482262 * H23 * np.power(n, 18) + + ( + -3.3026317142400005e12 + - 1.439265931975543e13 * n + - 2.830698051067102e13 * np.power(n, 2) + - 3.364494784620761e13 * np.power(n, 3) + - 2.722732245440367e13 * np.power(n, 4) + - 1.5993546865744523e13 * np.power(n, 5) + - 7.088282367887105e12 * np.power(n, 6) + - 2.4292290561525176e12 * np.power(n, 7) + - 6.538502415094675e11 * np.power(n, 8) + - 1.3947174479682452e11 * np.power(n, 9) + - 2.3664442495912846e10 * np.power(n, 10) + - 3.1898477113313265e9 * np.power(n, 11) + - 3.393902581329089e8 * np.power(n, 12) + - 2.8140522428972498e7 * np.power(n, 13) + - 1.7796946084567667e6 * np.power(n, 14) + - 82895.66604158795 * np.power(n, 15) + - 2679.5876073711893 * np.power(n, 16) + - 53.67200935767826 * np.power(n, 17) + - 0.501607564090451 * np.power(n, 18) + ) + * S1 + + 0.631966197838168 + * n + * (2.0 + 3.0 * n + 1.0 * np.power(n, 2)) + * np.power( + 1.8144e6 + + 2.59272e6 * n + + 1.580508e6 * np.power(n, 2) + + 537628.0 * np.power(n, 3) + + 111769.0 * np.power(n, 4) + + 14560.0 * np.power(n, 5) + + 1162.0 * np.power(n, 6) + + 52.0 * np.power(n, 7) + + 1.0 * np.power(n, 8), + 2, + ) + * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + ) + ) + + +# @nb.njit("c16(c16,c16)", cache=True) +def S21l21(n, S1): + return complex( + ( + complex(1.6833606003593822e27, 2.1316401151124944e27) + - 1.6833606028664177e27 * np.power(2.0, n) + + complex(1.1280238519747306e28, 1.4284014544217873e28) * n + - 9.793413137165368e27 * np.power(2.0, n) * n + + complex(3.5133648703234346e28, 4.4489029733809166e28) * np.power(n, 2) + - 2.6584983157605467e28 * np.power(2.0, n) * np.power(n, 2) + + complex(6.7936790083925e28, 8.602679035475088e28) * np.power(n, 3) + - 4.500022047614448e28 * np.power(2.0, n) * np.power(n, 3) + + complex(9.19012141317016e28, 1.1637229431490278e29) * np.power(n, 4) + - 5.351614784848519e28 * np.power(2.0, n) * np.power(n, 4) + + complex(9.2890946632445e28, 1.1762554569358886e29) * np.power(n, 5) + - 4.774123285176482e28 * np.power(2.0, n) * np.power(n, 5) + + complex(7.314978363595366e28, 9.262779365216703e28) * np.power(n, 6) + - 3.3296016110218174e28 * np.power(2.0, n) * np.power(n, 6) + + complex(4.618995743047189e28, 5.848922626855809e28) * np.power(n, 7) + - 1.867555495886855e28 * np.power(2.0, n) * np.power(n, 7) + + complex(2.3881423804543337e28, 3.024047281480256e28) * np.power(n, 8) + - 8.598161226007345e27 * np.power(2.0, n) * np.power(n, 8) + + complex(1.027023747870955e28, 1.3004956199394855e28) * np.power(n, 9) + - 3.299192196302645e27 * np.power(2.0, n) * np.power(n, 9) + + complex(3.718430053139092e27, 4.708559564429205e27) * np.power(n, 10) + - 1.0673974911524395e27 * np.power(2.0, n) * np.power(n, 10) + + complex(1.1441604044899806e27, 1.4488232559998715e27) * np.power(n, 11) + - 2.9379890367598923e26 * np.power(2.0, n) * np.power(n, 11) + + complex(3.014106578187488e26, 3.816692213649815e26) * np.power(n, 12) + - 6.927509956951886e25 * np.power(2.0, n) * np.power(n, 12) + + complex(6.836865750537136e25, 8.657362927743468e25) * np.power(n, 13) + - 1.4066600113346826e25 * np.power(2.0, n) * np.power(n, 13) + + complex(1.3411340313136578e25, 1.6982467451739608e25) * np.power(n, 14) + - 2.4692772904714515e24 * np.power(2.0, n) * np.power(n, 14) + + complex(2.2823563954140286e24, 2.890094902276634e24) * np.power(n, 15) + - 3.757351574332791e23 * np.power(2.0, n) * np.power(n, 15) + + complex(3.3768613922826975e23, 4.276041487375118e23) * np.power(n, 16) + - 4.963794071544808e22 * np.power(2.0, n) * np.power(n, 16) + + complex(4.348682972736758e22, 5.506637080449338e22) * np.power(n, 17) + - 5.696446468351613e21 * np.power(2.0, n) * np.power(n, 17) + + complex(4.875275445814089e21, 6.173449430059735e21) * np.power(n, 18) + - 5.67601106161025e20 * np.power(2.0, n) * np.power(n, 18) + + complex(4.754442901083716e20, 6.020442354673485e20) * np.power(n, 19) + - 4.902928615262456e19 * np.power(2.0, n) * np.power(n, 19) + + complex(4.0260266191939265e19, 5.098065797780899e19) * np.power(n, 20) + - 3.661480489217735e18 * np.power(2.0, n) * np.power(n, 20) + + complex(2.951591241364906e18, 3.7375329856855946e18) * np.power(n, 21) + - 2.354412432066986e17 * np.power(2.0, n) * np.power(n, 21) + + complex(1.8655124802380563e17, 2.3622562465222666e17) * np.power(n, 22) + - 1.296218655332279e16 * np.power(2.0, n) * np.power(n, 22) + + complex(1.0106075448696164e16, 1.2797095428905186e16) * np.power(n, 23) + - 6.06359582313501e14 * np.power(2.0, n) * np.power(n, 23) + + complex(4.6562817914004075e14, 5.896144952336889e14) * np.power(n, 24) + - 2.385660927511548e13 * np.power(2.0, n) * np.power(n, 24) + + complex(1.805881124487301e13, 2.286746791927984e13) * np.power(n, 25) + - 7.786891093408528e11 * np.power(2.0, n) * np.power(n, 25) + + complex(5.814854720381085e11, 7.363220583644232e11) * np.power(n, 26) + - 2.0694973396132874e10 * np.power(2.0, n) * np.power(n, 26) + + complex(1.5255184441562937e10, 1.93173001082478e10) * np.power(n, 27) + - 4.361551307055125e8 * np.power(2.0, n) * np.power(n, 27) + + complex(3.1755495944092846e8, 4.021127881543603e8) * np.power(n, 28) + - 7.009322268197093e6 * np.power(2.0, n) * np.power(n, 28) + + complex(5.043047411303078e6, 6.385899164941185e6) * np.power(n, 29) + - 80650.58350683903 * np.power(2.0, n) * np.power(n, 29) + + complex(57364.741155652126, 72639.7036051468) * np.power(n, 30) + - 591.4373566195608 * np.power(2.0, n) * np.power(n, 30) + + complex(416.0214728560528, 526.7988174426441) * np.power(n, 31) + - 2.076022092268843 * np.power(2.0, n) * np.power(n, 31) + + complex(1.4445189418954867, 1.8291625605647361) * np.power(n, 32) + + 1.9169483570505036e27 * S1 + + 1.2845375736034561e28 * n * S1 + + 4.000824147114336e28 * np.power(n, 2) * S1 + + 7.736245591539027e28 * np.power(n, 3) * S1 + + 1.046516608556964e29 * np.power(n, 4) * S1 + + 1.0577868889120365e29 * np.power(n, 5) * S1 + + 8.329862794375306e28 * np.power(n, 6) * S1 + + 5.259838441103391e28 * np.power(n, 7) * S1 + + 2.7194752185317597e28 * np.power(n, 8) * S1 + + 1.1695139926857725e28 * np.power(n, 9) * S1 + + 4.2343289831692154e27 * np.power(n, 10) * S1 + + 1.302902558717772e27 * np.power(n, 11) * S1 + + 3.43228756883164e26 * np.power(n, 12) * S1 + + 7.785421902632924e25 * np.power(n, 13) * S1 + + 1.527204937150373e25 * np.power(n, 14) * S1 + + 2.599014080923719e24 * np.power(n, 15) * S1 + + 3.845372699542644e23 * np.power(n, 16) * S1 + + 4.952026765401563e22 * np.power(n, 17) * S1 + + 5.551679975614853e21 * np.power(n, 18) * S1 + + 5.4140832679439185e20 * np.power(n, 19) * S1 + + 4.584605434053637e19 * np.power(n, 20) * S1 + + 3.3611009970855055e18 * np.power(n, 21) * S1 + + 2.1243375927292365e17 * np.power(n, 22) * S1 + + 1.1508214207239058e16 * np.power(n, 23) * S1 + + 5.302304689793915e14 * np.power(n, 24) * S1 + + 2.0564332012233316e13 * np.power(n, 25) * S1 + + 6.621621304810342e11 * np.power(n, 26) * S1 + + 1.737172538770829e10 * np.power(n, 27) * S1 + + 3.616133150885176e8 * np.power(n, 28) * S1 + + 5.742732474275174e6 * np.power(n, 29) * S1 + + 65323.672366324005 * np.power(n, 30) * S1 + + 473.74137896608875 * np.power(n, 31) * S1 + + 1.644935343632253 * np.power(n, 32) * S1 + + np.power(2.0, n) + * ( + 1.3570442448525208e27 + + 7.736441842782683e27 * n + + 2.0586154139209478e28 * np.power(n, 2) + + 3.418020155394567e28 * np.power(n, 3) + + 3.990470196270089e28 * np.power(n, 4) + + 3.497804616136419e28 * np.power(n, 5) + + 2.3990638748389658e28 * np.power(n, 6) + + 1.3244759164655748e28 * np.power(n, 7) + + 6.006923754991886e27 * np.power(n, 8) + + 2.2722885003172314e27 * np.power(n, 9) + + 7.25273617768887e26 * np.power(n, 10) + + 1.9707591366660945e26 * np.power(n, 11) + + 4.590225915847702e25 * np.power(n, 12) + + 9.212225005158819e24 * np.power(n, 13) + + 1.5991495582075087e24 * np.power(n, 14) + + 2.4074200060054864e23 * np.power(n, 15) + + 3.1479255232159525e22 * np.power(n, 16) + + 3.577085214505872e21 * np.power(n, 17) + + 3.530547563815296e20 * np.power(n, 18) + + 3.0218507756908265e19 * np.power(n, 19) + + 2.2367871200740178e18 * np.power(n, 20) + + 1.4260027848947278e17 * np.power(n, 21) + + 7.785624904017476e15 * np.power(n, 22) + + 3.612590748983618e14 * np.power(n, 23) + + 1.4101170841935729e13 * np.power(n, 24) + + 4.5671137945917285e11 * np.power(n, 25) + + 1.2045801726015282e10 * np.power(n, 26) + + 2.519734716536869e8 * np.power(n, 27) + + 4.019480007235419e6 * np.power(n, 28) + + 45909.66551176623 * np.power(n, 29) + + 334.2060621909171 * np.power(n, 30) + + 1.164481052930025 * np.power(n, 31) + ) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + + n + * ( + 1.9169468691324218e27 + + 1.2845365765569392e28 * n + + 4.000821041710599e28 * np.power(n, 2) + + 7.736239586734746e28 * np.power(n, 3) + + 1.0465157962601805e29 * np.power(n, 4) + + 1.0577860678673627e29 * np.power(n, 5) + + 8.329856328810687e28 * np.power(n, 6) + + 5.259834358464076e28 * np.power(n, 7) + + 2.7194731076995423e28 * np.power(n, 8) + + 1.1695130849195251e28 * np.power(n, 9) + + 4.2343256965211237e27 * np.power(n, 10) + + 1.302901547416519e27 * np.power(n, 11) + + 3.4322849047208846e26 * np.power(n, 12) + + 7.785415859658431e25 * np.power(n, 13) + + 1.52720375174763e25 * np.power(n, 14) + + 2.5990120635923536e24 * np.power(n, 15) + + 3.845369714798924e23 * np.power(n, 16) + + 4.9520229216829045e22 * np.power(n, 17) + + 5.551675666450765e21 * np.power(n, 18) + + 5.414079065581157e20 * np.power(n, 19) + + 4.584601875524113e19 * np.power(n, 20) + + 3.361098388229127e18 * np.power(n, 21) + + 2.1243359438374944e17 * np.power(n, 22) + + 1.1508205274666648e16 * np.power(n, 23) + + 5.302300574192681e14 * np.power(n, 24) + + 2.0564316050383676e13 * np.power(n, 25) + + 6.621616165167411e11 * np.power(n, 26) + + 1.737171190393121e10 * np.power(n, 27) + + 3.6161303440751326e8 * np.power(n, 28) + + 5.742728016817852e6 * np.power(n, 29) + + 65323.62166267675 * np.power(n, 30) + + 473.7410112522892 * np.power(n, 31) + + 1.6449340668482266 * np.power(n, 32) + ) + * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) + ) + / ( + np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + * np.power(11.0 + n, 2) + * np.power(12.0 + n, 2) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + * (16.0 + n) + * (17.0 + n) + * (18.0 + n) + * (19.0 + n) + * (20.0 + n) + ) + ) + + +# @nb.njit("c16(c16,c16,c16, c16,c16)", cache=True) +def S1111l21105(n, S1, H21, H23, H24): + return complex( + 0.08333333333333333 + * ( + -2.882718083509208 * (H21 + H23) + + 8.317766166719343 * H24 + - 0.6660493039778589 * S1 + + ( + -21.28497824694114 + + np.power(n, 22) * (-1.4032651231697697 + 0.6651555702169106 * S1) + + 3.306657872663145e17 * S1 + + np.power(n, 21) * (-225.8619793647119 + 108.42035794535643 * S1) + + np.power(n, 20) * (-17161.340432724224 + 8352.358495213746 * S1) + + np.power(n, 19) * (-818456.95859745 + 404404.6093583284 * S1) + + np.power(n, 18) * (-2.7478728153544266e7 + 1.380478237788493e7 * S1) + + np.power(n, 17) * (-6.904019105536251e8 + 3.5325744384996516e8 * S1) + + np.power(n, 16) * (-1.3470591633763092e10 + 7.033776682829219e9 * S1) + + np.power(n, 15) + * (-2.0903754546392337e11 + 1.1164307832844762e11 * S1) + + np.power(n, 14) + * (-2.6209568351289272e12 + 1.4356036433688328e12 * S1) + + np.power(n, 13) * (-2.68237465524399e13 + 1.5115872138017662e13 * S1) + + np.power(n, 12) * (-2.254287456569634e14 + 1.311899520263152e14 * S1) + + np.power(n, 11) * (-1.5596729430294308e15 + 9.416388908315981e14 * S1) + + np.power(n, 10) * (-8.878314402636898e15 + 5.592104439069029e15 * S1) + + np.power(n, 9) * (-4.142544242067615e16 + 2.7412580442697824e16 * S1) + + np.power(n, 8) * (-1.5728620543904387e17 + 1.1033207871178562e17 * S1) + + np.power(n, 7) * (-4.8039406140988416e17 + 3.614468871513744e17 * S1) + + np.power(n, 6) * (-1.1601637307682578e18 + 9.513458515809779e17 * S1) + + n * (-4.7010131790074784e17 + 1.4714664237290086e18 * S1) + + np.power(n, 5) * (-2.1596907094790292e18 + 1.9743867729749857e18 * S1) + + np.power(n, 2) * (-1.7031784220857746e18 + 2.980594864657508e18 * S1) + + np.power(n, 4) * (-2.9809599710714127e18 + 3.143983341049741e18 * S1) + + np.power(n, 3) * (-2.8638554267864535e18 + 3.686977129250879e18 * S1) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + * np.power(11.0 + n, 2) + * np.power(12.0 + n, 2) + * (13.0 + n) + ) + - ( + 2.0794415416798357 + * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) + * ( + 2.0 + * ( + -0.4804530139182014 * np.power(2.0, n) + - 1.3862943611198906 * H21 * n + + 2.0 * H22 * n + + 0.4804530139182014 * n * S1 + + 1.5093876589204962 * n * 1 / np.tan(3.141592653589793 * n) + ) + + 0.4804530139182014 + * np.power(2.0, n) + * n + * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n) + ) + * np.sin(3.141592653589793 * n) + ) + / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) + - ( + 0.33302465198892944 + * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) + * ( + 6.283185307179586 * n * np.cos(3.141592653589793 * n) + + np.power(2.0, n) + * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) + * np.sin(3.141592653589793 * n) + ) + ) + / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) + + 1.441359041754604 + * ( + 2.0 * H23 + + 1.3862943611198906 * S1 + + ( + 0.6931471805599453 + * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) + * ( + 6.283185307179586 * n * np.cos(3.141592653589793 * n) + + np.power(2.0, n) + * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) + * np.sin(3.141592653589793 * n) + ) + ) + / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) + ) + ) + ) + + +# @nb.njit("c16(c16,c16,c16)", cache=True) +def S1111l21051(n, S1, H21): + return complex( + ( + complex(0.00008138020833333333, 0.00011869952602801132) + - complex(1.1108200333002769e12, 0.000021919931066000538) * n + - complex(3.0545253221968545e12, 0.000416485473072374) * np.power(n, 2) + - complex(3.746669508953097e12, 0.0005080718865495499) * np.power(n, 3) + - complex(2.732663230220466e12, 0.00037230189267925355) * np.power(n, 4) + - complex(1.3303092958914858e12, 0.00019969252622130892) * np.power(n, 5) + - complex(4.592245894160175e11, 0.00007079577081180635) * np.power(n, 6) + - complex(1.1640732704756241e11, 0.000015694489505731582) * np.power(n, 7) + - complex(2.2109629870529408e10, 2.5755745976631705e-6) * np.power(n, 8) + - complex(3.1780932871117997e9, 4.259823137078089e-7) * np.power(n, 9) + - complex(3.4627926147031265e8, 5.3381447021793165e-8) * np.power(n, 10) + - complex(2.84068280075561e7, 3.5211097252823663e-9) * np.power(n, 11) + - complex(1.72524518874892e6, 2.480870637667729e-10) * np.power(n, 12) + - complex(75180.21417891773, 2.672155268808036e-12) * np.power(n, 13) + - complex(2221.544934523533, 3.024184544294806e-13) * np.power(n, 14) + - 39.8447173169642 * np.power(n, 15) + - 0.3272966537768275 * np.power(n, 16) + + H21 + * ( + -4.302076232534848e12 + - 1.53507931440122e13 * n + - 2.3853545410321223e13 * np.power(n, 2) + - 2.170803074046334e13 * np.power(n, 3) + - 1.3064271224116332e13 * np.power(n, 4) + - 5.547952832953075e12 * np.power(n, 5) + - 1.7279086122273728e12 * np.power(n, 6) + - 4.041008596208101e11 * np.power(n, 7) + - 7.193431686649904e10 * np.power(n, 8) + - 9.803816052654116e9 * np.power(n, 9) + - 1.0217751899949871e9 * np.power(n, 10) + - 8.073087028086561e7 * np.power(n, 11) + - 4.748284771638826e6 * np.power(n, 12) + - 201274.13241954896 * np.power(n, 13) + - 5806.617255974238 * np.power(n, 14) + - 101.98591214459 * np.power(n, 15) + - 0.8224670334241131 * np.power(n, 16) + ) + + complex(7.708392419040001e11, 0.00009449713909064082) * S1 + + complex(2.7505309320805107e12, 0.0003858633179534501) * n * S1 + + complex(4.2740406880192827e12, 0.0006260435464754956) + * np.power(n, 2) + * S1 + + complex(3.8896107494933716e12, 0.0005118595034076379) + * np.power(n, 3) + * S1 + + complex(2.3408355366339976e12, 0.0002323054669311587) + * np.power(n, 4) + * S1 + + complex(9.940734484272197e11, 0.00007481023511342399) + * np.power(n, 5) + * S1 + + complex(3.0960394301147516e11, 0.000027684708717961177) + * np.power(n, 6) + * S1 + + complex(7.24061554109936e10, 0.000010043397107127028) + * np.power(n, 7) + * S1 + + complex(1.2889077571640892e10, 2.3570453394597503e-6) + * np.power(n, 8) + * S1 + + complex(1.7566323154951086e9, 3.441363097579897e-7) * np.power(n, 9) * S1 + + complex(1.8308006885037723e8, 3.4608702131655363e-8) + * np.power(n, 10) + * S1 + + complex(1.4465230154437648e7, 1.9284163711165284e-9) + * np.power(n, 11) + * S1 + + complex(850790.1849888319, 4.107008214012321e-12) * np.power(n, 12) * S1 + + complex(36063.98196197322, 1.1734309182892347e-12) * np.power(n, 13) * S1 + + complex(1040.4205322471842, 1.1734309182892347e-13) * np.power(n, 14) * S1 + + 18.27367507063043 * np.power(n, 15) * S1 + + 0.14736834734379375 * np.power(n, 16) * S1 + + n + * ( + -2.196022510565852e12 + - 7.835911191984595e12 * n + - 1.2176195828823182e13 * np.power(n, 2) + - 1.1081004052321111e13 * np.power(n, 3) + - 6.668741356866405e12 * np.power(n, 4) + - 2.831988242464008e12 * np.power(n, 5) + - 8.820220757492529e11 * np.power(n, 6) + - 2.062758854794705e11 * np.power(n, 7) + - 3.671933517271283e10 * np.power(n, 8) + - 5.004421023099778e9 * np.power(n, 9) + - 5.2157172413576376e8 * np.power(n, 10) + - 4.1209592497130744e7 * np.power(n, 11) + - 2.4237925321355704e6 * np.power(n, 12) + - 102741.67673860745 * np.power(n, 13) + - 2964.0251625309274 * np.power(n, 14) + - 52.059365460883136 * np.power(n, 15) + - 0.419833592426477 * np.power(n, 16) + ) + * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * np.power(4.0 + n, 2) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + ) + + +# @nb.njit("c16(c16)", cache=True) +def S3l2(n): + return complex( + 2.0 * ((1.38104 - 0.377347j) - 2 ** n * mp.lerchphi(2.0, 3.0, 1.0 + n)) + ) + + +# @nb.njit("c16(c16,c16)", cache=True) +def S112l2051(n, S1): + return complex( + -0.7512855644747464 * S1 + + ( + -0.00009170966363217119 + + np.power(n, 16) * (-1.1551344276377544 + 0.7512855644747464 * S1) + + 9.824368757120372e11 * S1 + + np.power(n, 15) * (-138.12633167732008 + 90.90555330144431 * S1) + + np.power(n, 14) * (-7543.3310441845915 + 5033.6132819808 * S1) + + np.power(n, 13) * (-249212.9318573135 + 169024.22629552844 * S1) + + np.power(n, 12) * (-5.5609596917238e6 + 3.8450960472641704e6 * S1) + + np.power(n, 11) * (-8.860864646926463e7 + 6.270086727106097e7 * S1) + + np.power(n, 10) * (-1.0392528981358187e9 + 7.562847839035856e8 * S1) + + np.power(n, 9) * (-9.112653779990723e9 + 6.863537366891241e9 * S1) + + np.power(n, 8) * (-6.0048063053520065e10 + 4.7209851439097336e10 * S1) + + np.power(n, 7) * (-2.962939969277478e11 + 2.4599669313036557e11 * S1) + + np.power(n, 6) * (-1.0811050344017815e12 + 9.635051930282513e11 * S1) + + np.power(n, 5) * (-2.849355344696549e12 + 2.792141871178878e12 * S1) + + n * (-1.2515090782257412e12 + 4.242387400717028e12 * S1) + + np.power(n, 4) * (-5.216229253731701e12 + 5.832837664170654e12 * S1) + + np.power(n, 2) * (-4.2583318206830425e12 + 7.892240292128241e12 * S1) + + np.power(n, 3) * (-6.210399061644802e12 + 8.43153763901703e12 * S1) + ) + / ( + np.power(1.0 + n, 2) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - ( + 0.3756427822373732 + * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) + * ( + 6.283185307179586 * n * np.cos(3.141592653589793 * n) + + np.power(2.0, n) + * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) + * np.sin(3.141592653589793 * n) + ) + ) + / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) + ) + diff --git a/src/eko/matching_conditions/n3lo/f_functions.py b/src/eko/matching_conditions/n3lo/f_functions.py index 4127f2b75..0c253be04 100644 --- a/src/eko/matching_conditions/n3lo/f_functions.py +++ b/src/eko/matching_conditions/n3lo/f_functions.py @@ -2,7 +2,8 @@ """ This module contains some Mellin transfomations for 5th order harmonics sum. Notation refers to :cite:`Bl_mlein_2009` -Mellin transform is defined with the convention x^(N) +Mellin transform is defined with the convention x^(N). +F19, F20, F21 are not present explictly in the paper """ import numba as nb import numpy as np @@ -5455,6 +5456,7 @@ def F13(n, S1, S2): @nb.njit("c16(c16,c16,c16,c16)", cache=True) def F19(n, S1, S2, S3): + """Mellin tranfrom of eq 9.3 of :cite:`Bl_mlein_2009`""" return ( 7.548974594558902 - 1.5497677311665408 / np.power(1.0 + n, 3) @@ -5502,6 +5504,7 @@ def F19(n, S1, S2, S3): @nb.njit("c16(c16,c16,c16,c16)", cache=True) def F21(n, Sm1, Sm2, Sm3): + """Mellin transform of eq 9.4 of :cite:`Bl_mlein_2009`""" return 2.3148148148148148e-7 * ( 2.383072892806571e7 / np.power(-1.0, 1.0 * n) + 970000.0 / (2.0 + n) @@ -5563,6 +5566,7 @@ def F21(n, Sm1, Sm2, Sm3): @nb.njit("c16(c16,c16,c16,c16)", cache=True) def F20(n, Sm1, Sm2, Sm3): + """Mellin transform of eq 9.5 :cite:`Bl_mlein_2009`""" return 2.3148148148148148e-7 * ( 1.8204889223408133e7 / np.power(-1.0, 1.0 * n) - 650000.0 / (2.0 + n) @@ -5624,6 +5628,7 @@ def F20(n, Sm1, Sm2, Sm3): @nb.njit("c16(c16,c16,c16)", cache=True) def F14F12(n, S1, S21): + """Linear combination of :math:`M[( 2 S_{2,2}(x)- Li_2(x)^2/2)/(1+x)](N)`""" return ( -0.5626569734260486 + 0.49999902059348167 diff --git a/src/eko/matching_conditions/n3lo/h_functions.py b/src/eko/matching_conditions/n3lo/h_functions.py new file mode 100644 index 000000000..81b78736a --- /dev/null +++ b/src/eko/matching_conditions/n3lo/h_functions.py @@ -0,0 +1,405 @@ +# -*- coding: utf-8 -*- +"""This module contains some Mellin transform used for in the generalized haromonic sums. +Mellin transform is defined with the convention x^(n) +""" +import numba as nb +import numpy as np +import mpmath as mp + +# @nb.njit("c16(c16,c16)", cache=True) +def H21(n, S1): + """Mellin transform of :math:`\int_{1}^{2} (x^(n)-1)(ln(1-x/2))/(x-1)`""" + return complex( + complex(-2.4674011002723395, -2.177586090303602) * (-1.0 + np.power(2.0, n)) + - 1.0 + * np.power(2.0, n) + * n + * ( + -0.00017861624734509784 + - (18.448868614597806 * (1.0 - 1.0 * np.power(2.0, -1.0 - 1.0 * n))) + / (1.0 + n) + + (53.03705951583224 * (1.0 - 1.0 * np.power(2.0, -2.0 - 1.0 * n))) + / (2.0 + n) + - (72.59017758173087 * (1.0 - 1.0 * np.power(2.0, -3.0 - 1.0 * n))) + / (3.0 + n) + + (48.721104697124765 * (1.0 - 1.0 * np.power(2.0, -4.0 - 1.0 * n))) + / (4.0 + n) + - (11.36436613468647 * (1.0 - 1.0 * np.power(2.0, -5.0 - 1.0 * n))) + / (5.0 + n) + - (8.388218542825193 * (1.0 - 1.0 * np.power(2.0, -6.0 - 1.0 * n))) + / (6.0 + n) + + (16.758614450512397 * (1.0 - 1.0 * np.power(2.0, -7.0 - 1.0 * n))) + / (7.0 + n) + - (22.231044375187043 * (1.0 - 1.0 * np.power(2.0, -8.0 - 1.0 * n))) + / (8.0 + n) + + (22.160106312069402 * (1.0 - 1.0 * np.power(2.0, -9.0 - 1.0 * n))) + / (9.0 + n) + - (15.945856292428402 * (1.0 - 1.0 * np.power(2.0, -10.0 - 1.0 * n))) + / (10.0 + n) + + (7.88216704187177 * (1.0 - 1.0 * np.power(2.0, -11.0 - 1.0 * n))) + / (11.0 + n) + - (2.400714286203908 * (1.0 - 1.0 * np.power(2.0, -12.0 - 1.0 * n))) + / (12.0 + n) + + (0.3429689205921761 * (1.0 - 1.0 * np.power(2.0, -13.0 - 1.0 * n))) + / (13.0 + n) + + ( + 17.066666666666666 + * ( + -1.3862943611198906 * np.power(2.0, -1.0 - 1.0 * n) + + S1 + + mp.betainc(1.0 + n, 0.0, x2=0.5) + ) + ) + / n + - ( + 62.0 + * ( + -1.3862943611198906 * np.power(2.0, -2.0 - 1.0 * n) + + 1 / (1.0 + n) + + S1 + + mp.betainc(2.0 + n, 0.0, x2=0.5) + ) + ) + / (1.0 + n) + + ( + 98.0 + * ( + -1.3862943611198906 * np.power(2.0, -3.0 - 1.0 * n) + + (3.0 + 2.0 * n) / ((1.0 + n) * (2.0 + n)) + + S1 + + mp.betainc(3.0 + n, 0.0, x2=0.5) + ) + ) + / (2.0 + n) + - ( + 82.66666666666667 + * ( + -1.3862943611198906 * np.power(2.0, -4.0 - 1.0 * n) + + (11.0 + 12.0 * n + 3.0 * np.power(n, 2)) + / ((1.0 + n) * (2.0 + n) * (3.0 + n)) + + S1 + + mp.betainc(4.0 + n, 0.0, x2=0.5) + ) + ) + / (3.0 + n) + + ( + 36.0 + * ( + -1.3862943611198906 * np.power(2.0, -5.0 - 1.0 * n) + + (2.0 * (5.0 + 2.0 * n) * (5.0 + 5.0 * n + np.power(n, 2))) + / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n)) + + S1 + + mp.betainc(5.0 + n, 0.0, x2=0.5) + ) + ) + / (4.0 + n) + - ( + 6.4 + * ( + -1.3862943611198906 * np.power(2.0, -6.0 - 1.0 * n) + + ( + 274.0 + + 450.0 * n + + 255.0 * np.power(n, 2) + + 60.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + + mp.betainc(6.0 + n, 0.0, x2=0.5) + ) + ) + / (5.0 + n) + - ( + 0.6931471805599453 + * ( + complex(0.0, 3.141592653589793) * np.power(2.0, n) + + S1 + + mp.betainc(1.0 + n, 0.0, x2=2.0) + ) + ) + / (np.power(2.0, 1.0 * n) * n) + ) + ) + + +# @nb.njit("c16(c16,c16)", cache=True) +def H23(n, S1): + r"""Mellin transform of :math:`\int_{0}^{1} (x^(n)-1)(ln(1-x/2))/(x-1)`""" + return complex( + 0.038644077596632104 * n + + (0.17990633019243982 * n) / (2.0 + n) + - (0.08838707737246981 * n) / (3.0 + n) + + (0.006557861587551356 * n) / (4.0 + n) + + (0.0024537382629694544 * n) / (5.0 + n) + - (0.00005974273075922878 * n) / (6.0 + n) + + (0.0018925349638931536 * n) / (7.0 + n) + - (0.0019617338775610098 * n) / (8.0 + n) + + (0.0017680265456417688 * n) / (9.0 + n) + - (0.0008335702736569231 * n) / (10.0 + n) + + (0.00020568989536588186 * n) / (11.0 + n) + + 0.14018613535141447 * (-1.0 + 1 / (1.0 + n)) + - 0.027777777777777776 + * n + * (1.391186796731926 - 30.0 / (1.0 + n) + 3.0 / (2.0 + n) - 4.0 / (3.0 + n)) + - 0.6931471805599453 * S1 + ) + + +# @nb.njit("c16(c16,c16,c16)", cache=True) +def H26(n, S1, S2): + """Linear combination of S211l2051 + S211l2105 - S22l205""" + return complex( + 0.08333333333333333 + * ( + complex(-16.23484850566707, 21.491913260611398) + + ( + -2.842170943040401e-14 + + 173.50286458333323 * n + + 243.46289062500009 * np.power(n, 2) + + 119.69466145833336 * np.power(n, 3) + + 24.755859375 * np.power(n, 4) + + 1.8337239583333333 * np.power(n, 5) + ) + / ( + 120.0 + + 274.0 * n + + 225.0 * np.power(n, 2) + + 85.0 * np.power(n, 3) + + 15.0 * np.power(n, 4) + + np.power(n, 5) + ) + + ( + 8.731149137020111e-11 + - 787729.060111111 * n + - 3.0080453892458337e6 * np.power(n, 2) + - 5.05889901240764e6 * np.power(n, 3) + - 4.936113066185765e6 * np.power(n, 4) + - 3.095514310441841e6 * np.power(n, 5) + - 1.3041688939354168e6 * np.power(n, 6) + - 373993.2982185764 * np.power(n, 7) + - 72116.17108854167 * np.power(n, 8) + - 8953.494551215279 * np.power(n, 9) + - 646.6595444444445 * np.power(n, 10) + - 20.644269618055556 * np.power(n, 11) + ) + / ( + np.power(1.0 + n, 2) + * np.power(2.0 + n, 3) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + ) + + ( + np.power(n, 3) * (1.283807919976604e10 - 1.608646369206041e10 * S1) + + np.power(n, 2) * (9.294220799968464e9 - 1.5655859137235104e10 * S1) + + np.power(n, 4) * (1.0596601907417942e10 - 1.0982580115748644e10 * S1) + + n * (3.028465456549388e9 - 9.00503846537143e9 * S1) + + np.power(n, 5) * (5.843292892011012e9 - 5.294110506123972e9 * S1) + + np.power(n, 6) * (2.2769289339052258e9 - 1.8644748220271614e9 * S1) + + np.power(n, 7) * (6.458907520321677e8 - 4.886203781899511e8 * S1) + + np.power(n, 8) * (1.3519818853965065e8 - 9.595384412927225e7 * S1) + + np.power(n, 9) * (2.090277859286008e7 - 1.4075312614993623e7 * S1) + + np.power(n, 10) * (2.3595465377532723e6 - 1.5203445475602325e6 * S1) + + np.power(n, 11) * (189161.71919246286 - 117403.416519983 * S1) + + np.power(n, 12) * (10205.69539860453 - 6133.497436933107 * S1) + + np.power(n, 13) * (332.32934015883137 - 194.2227274659864 * S1) + + np.power(n, 14) * (4.93556152059038 - 2.8148221371882087 * S1) + - 2.288031552e9 * S1 + ) + / ( + (1.0 + n) + * (2.0 + n) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + ) + + 18.614449574968226 * S1 + + 1.6449340668482262 * (9.869604401089358 - 6.0 * S2) + + 16.848146067756026 * S2 + + 6.841088463857115 * mp.betainc(1.0 + n, 0.0, x2=2.0) + + ( + complex(2.923121728206675e19, 3.701550063528897e19) + - 2.9231217212083933e19 * np.power(2.0, n) + + 1.1782399794254862e19 * S1 + + np.power(n, 21) + * ( + complex(6.758658057013846, 15.214546459695082) + + 4.8429405519235385 * S1 + ) + + np.power(n, 20) + * ( + complex(1431.8422861969393, 3210.269302995662) + - 17.26786632043568 * np.power(2.0, n) + + 1021.8604564558666 * S1 + ) + + np.power(n, 19) + * ( + complex(141958.51946738732, 316842.9300231501) + - 3589.81189979833 * np.power(2.0, n) + + 100854.23699380769 * S1 + ) + + np.power(n, 18) + * ( + complex(8.752539210101698e6, 1.943605059313438e7) + - 348830.0180568167 * np.power(2.0, n) + + 6.186687052163003e6 * S1 + ) + + np.power(n, 17) + * ( + complex(3.761407002787435e8, 8.304829147349784e8) + - 2.1047447076496072e7 * np.power(2.0, n) + + 2.6435092206687373e8 * S1 + ) + + np.power(n, 16) + * ( + complex(1.1968726692676088e10, 2.6254354741564106e10) + - 8.83520877339768e8 * np.power(2.0, n) + + 8.357020669616135e9 * S1 + ) + + np.power(n, 15) + * ( + complex(2.923873280138507e11, 6.36638280062443e11) + - 2.7398953857335464e10 * np.power(2.0, n) + + 2.0264825846692044e11 * S1 + ) + + np.power(n, 14) + * ( + complex(5.611456769193843e12, 1.2115084031103225e13) + - 6.505518151452606e11 * np.power(2.0, n) + + 3.8563510190475283e12 * S1 + ) + + np.power(n, 13) + * ( + complex(8.586610348984605e13, 1.8358462356351503e14) + - 1.2095125413375354e13 * np.power(2.0, n) + + 5.843680063159655e13 * S1 + ) + + np.power(n, 12) + * ( + complex(1.0571874861459436e15, 2.2349477992893992e15) + - 1.785829223423589e14 * np.power(2.0, n) + + 7.114059796185222e14 * S1 + ) + + np.power(n, 11) + * ( + complex(1.0523151695692176e16, 2.1956419230015896e16) + - 2.1112713439294792e15 * np.power(2.0, n) + + 6.988945306109954e15 * S1 + ) + + np.power(n, 10) + * ( + complex(8.47844216720592e16, 1.7420404467752794e17) + - 2.005909067824641e16 * np.power(2.0, n) + + 5.5450869634059896e16 * S1 + ) + + np.power(n, 9) + * ( + complex(5.5174139967361075e17, 1.1132957115890166e18) + - 1.531123605403968e17 * np.power(2.0, n) + + 3.543730312448022e17 * S1 + ) + + np.power(n, 8) + * ( + complex(2.884166025765176e18, 5.695785397422142e18) + - 9.350839180163167e17 * np.power(2.0, n) + + 1.813024801580739e18 * S1 + ) + + np.power(n, 7) + * ( + complex(1.1999636924131482e19, 2.3095399249450648e19) + - 4.5317048835340575e18 * np.power(2.0, n) + + 7.351493906461836e18 * S1 + ) + + np.power(n, 6) + * ( + complex(3.919356154375745e19, 7.313065470087013e19) + - 1.720130723544719e19 * np.power(2.0, n) + + 2.327821037438006e19 * S1 + ) + + n + * ( + complex(1.2214732964559317e20, 1.701876351998952e20) + - 1.0858123503594557e20 * np.power(2.0, n) + + 5.417240679036713e19 * S1 + ) + + np.power(n, 5) + * ( + complex(9.853818099925572e19, 1.7706371703968426e20) + - 5.015528326226779e19 * np.power(2.0, n) + + 5.636113161818078e19 * S1 + ) + + np.power(n, 4) + * ( + complex(1.8537407017470958e20, 3.181170428188106e20) + - 1.0918493529864626e20 * np.power(2.0, n) + + 1.012597996927796e20 * S1 + ) + + np.power(n, 2) + * ( + complex(2.266977589532697e20, 3.4319007865484195e20) + - 1.7687906077677814e20 * np.power(2.0, n) + + 1.0924079487602891e20 * S1 + ) + + np.power(n, 3) + * ( + complex(2.502191229329443e20, 4.0584332549912664e20) + - 1.7002838382983096e20 * np.power(2.0, n) + + 1.2918394274807806e20 * S1 + ) + + np.power(2.0, n) + * ( + 2.3564799588509725e19 + + 8.478001399222454e19 * n + + 1.3370157575983325e20 * np.power(n, 2) + + 1.2466630973632286e20 * np.power(n, 3) + + 7.785328964923633e19 * np.power(n, 4) + + 3.486897358712523e19 * np.power(n, 5) + + 1.1687447161634896e19 * np.power(n, 6) + + 3.0155406512887823e18 * np.power(n, 7) + + 6.105089518726959e17 * np.power(n, 8) + + 9.82371106169081e16 * np.power(n, 9) + + 1.2664628651211698e16 * np.power(n, 10) + + 1.3132619610082072e15 * np.power(n, 11) + + 1.0954999822883712e14 * np.power(n, 12) + + 7.32360303435598e12 * np.power(n, 13) + + 3.89099003739077e11 * np.power(n, 14) + + 1.6197513194763893e10 * np.power(n, 15) + + 5.165281444683772e8 * np.power(n, 16) + + 1.2173699665370196e7 * np.power(n, 17) + + 199674.43895580748 * np.power(n, 18) + + 2034.0350318078856 * np.power(n, 19) + + 9.685881103847077 * np.power(n, 20) + ) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + np.power(1.0 + n, 2) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + * (16.0 + n) + * (17.0 + n) + * (18.0 + n) + * (19.0 + n) + * (20.0 + n) + ) + + 20.523265391571346 + * n + * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) + ) + ) diff --git a/tests/test_cs_functions.py b/tests/test_cs_functions.py new file mode 100644 index 000000000..143716549 --- /dev/null +++ b/tests/test_cs_functions.py @@ -0,0 +1,311 @@ +# -*- coding: utf-8 -*- +# Test cs functions +import numpy as np + +from eko.anomalous_dimensions import harmonics +import eko.matching_conditions.n3lo.cs_functions as csf +import eko.matching_conditions.n3lo.h_functions as hf + + +# reference values coming fom mathematica +testNinteger = [1, 2, 10, 100] +refvalsinteger = { + "S1l05": [0.5, 0.625, 0.693065, 0.693147], + "S111l211": [2.0, 5.5, 1092.6, 3.64201e29], + "S12l21": [2.0, 4.5, 361.913, 4.18766e28], + "S21l21": [2.0, 3.5, 80.0103, 1.33999e27], + "S3l2": [2.0, 2.5, 6.1981, 2.61629e24], + "S1111l20511": [1.0, 2.4375, 211.939, 2.30926e28], + "S1111l21051": [1.0, 2.6875, 438.767, 9.83117e28], + "S121l2051": [1.0, 2.3125, 177.276, 1.92438e28], + "S13l205": [1.0, 2.0625, 127.392, 1.37604e28], + "S211l2051": [1.0, 1.6875, 24.6954, 2.1289e26], + "S22l205": [1.0, 1.5625, 17.9259, 1.50709e26], +} + + +testN = [1.2, 2 + 2j, 10 - 10j, 100 + 5j] +refvals = { + "S1l05": [ + 0.538137, + 0.712215 + 0.0553881j, + 0.693133 - 0.0000611141j, + 0.693147 - 2.81649e-33j, + ], + "S111l211": [ + 2.54956, + 0.757758 + 7.14874j, + 909.774 - 228.694j, + -3.48531e29 - 1.04752e29j, + ], + "S12l21": [ + 2.44162, + 2.49213 + 5.02065j, + 237.335 + 37.1463j, + -4.02641e28 - 1.13156e28j, + ], + "S21l21": [ + 2.30848, + 3.16611 + 2.64925j, + 27.0649 + 23.3928j, + -1.30088e27 - 3.08519e26j, + ], + "S3l2": [ + 2.13581, + 2.68836 + 0.514803j, + 2.47645 + 0.00409976j, + -2.56754e24 - 4.47673e23j, + ], + "S1111l20511": [ + 1.24503, + 1.1248 + 3.00684j, + 131.725 + 24.7849j, + -2.22049e28 - 6.23296e27j, + ], + "S1111l21051": [ + 1.26935, + 0.553945 + 3.4886j, + 348.464 - 34.3895j, + -9.42727e28 - 2.75605e28j, + ], + "S1111l21105": [ + 1.28092, + 0.240202 + 3.69116j, + 518.932 - 150.299j, + -2.12395e29 - 6.4095e28j, + ], + "S112l2051": [ + 1.23026 - 7.87292e-16j, + 1.26939 + 2.68422j, + 110.53 + 20.4704j, + -1.85041e28 - 5.19414e27j, + ], + "S112l2105": [ + 1.25606 + 1.90605e-16j, + 0.778372 + 3.21344j, + 276.555 - 18.8422j, + -7.17239e28 - 2.09103e28j, + ], + "S121l2051": [ + 1.23026 - 7.87292e-16j, + 1.26939 + 2.68422j, + 110.53 + 20.4704j, + -1.85041e28 - 5.19414e27j, + ], + "S121l2105": [ + 1.22865 - 5.91011e-18j, + 1.18968 + 2.66297j, + 132.763 + 19.9346j, + -2.26363e28 - 6.36336e27j, + ], + "S13l205": [ + 1.19667, + 1.39248 + 2.05457j, + 79.7069 + 14.5882j, + -1.32315e28 - 3.71411e27j, + ], + "S211l2051": [ + 1.14671, + 1.64933 + 1.16434j, + 5.5855 + 6.21788j, + -2.07082e26 - 4.69937e25j, + ], + "S211l2105": [ + 1.1634, + 1.57541 + 1.47654j, + 16.9764 + 14.4009j, + -8.41216e26 - 2.00123e26j, + ], + "S22l205": [ + 1.12596, + 1.5831 + 0.877058j, + 4.40596 + 4.39592j, + -1.46597e26 - 3.32677e25j, + ], + "S31l205": [ + 1.08185, + 1.42797 + 0.349638j, + 1.28279 + 0.00292271j, + -1.77969e24 - 3.10303e23j, + ], +} + +# compare the exact values of some harmonics +def test_S1l05(): + for N, vals in zip(testN, refvals["S1l05"]): + test = csf.S1l05(N) + np.testing.assert_allclose(test, vals, rtol=1e-05) + for N, vals in zip(testNinteger, refvalsinteger["S1l05"]): + test = csf.S1l05(N) + np.testing.assert_allclose(test, vals, rtol=1e-05) + + +# TODO: still on going +# def test_S111l211(): +# for N, vals in zip(testN, refvals["S111l211"]): +# S1 = harmonics.harmonic_S1(N) +# H24 = hf.H24(n,S1) +# test = csf.S111l211(H24) +# np.testing.assert_allclose(test, vals), rtol=1e-05) +# +# +# def test_S12l21(): +# for N, vals in zip(testN, refvals["S12l21"]): +# test = csf.S12l21(H25) +# np.testing.assert_allclose(test - 1.0j * imtest, vals), rtol=8e-03) + + +def test_S21l21(): + for N, vals in zip(testN, refvals["S21l21"]): + S1 = harmonics.harmonic_S1(N) + test = csf.S21l21(N, S1) + rtol = 15e-02 + if N == 100 + 5j: + rtol = 25e-01 + np.testing.assert_allclose(test, vals, rtol=rtol) + + +def test_S3l2(): + for N, vals in zip(testN, refvals["S3l2"]): + test = csf.S3l2(N) + # TODO: here Mathematica and MPmath do not agree on LerchPhi, + # when the 3rd argument is complez and first real... + np.testing.assert_allclose(np.real(test), np.real(vals), rtol=1e-05) + + for N, vals in zip(testNinteger, refvalsinteger["S3l2"]): + test = csf.S3l2(N) + np.testing.assert_allclose(test, vals, rtol=1e-05) + + +def test_S1111l20511(): + for N, vals in zip(testN, refvals["S1111l20511"]): + S1 = harmonics.harmonic_S1(N) + test = csf.S1111l20511(N, S1) + np.testing.assert_allclose(test, vals, rtol=3e-03) + + +def test_S1111l21051(): + for N, vals in zip(testN, refvals["S1111l21051"]): + S1 = harmonics.harmonic_S1(N) + H21 = hf.H21(N, S1) + test = csf.S1111l21051(N, S1, H21) + rtol = 6e-03 + if N == 100 + 5j: + rtol = 2e-01 + np.testing.assert_allclose(test, vals, rtol=rtol) + + +# TODO: still on going +# def test_S1111l21105(): +# for N, vals in zip(testN, refvals["S1111l21105"]): +# S1 = harmonics.harmonic_S1(N) +# H21 = hf.H21(N,S1) +# H23 = hf.H23(N,S1) +# H24 = hf.H24(N,S1) +# test = csf.S1111l21105(N, S1, H21,H23,H24) +# np.testing.assert_allclose(test, vals), rtol=15e-03) + + +def test_S112l2051(): + for N, vals in zip(testN, refvals["S112l2051"]): + S1 = harmonics.harmonic_S1(N) + test = csf.S112l2051(N, S1) + np.testing.assert_allclose(test, vals, rtol=5e-03) + + +def test_S112l2105(): + for N, vals in zip(testN, refvals["S112l2105"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + H21 = hf.H21(N, S1) + H23 = hf.H23(N, S1) + test = csf.S112l2105(N, S1, S2, H21, H23) + rtol = 6e-03 + if N == 100 + 5j: + rtol = 2e-01 + np.testing.assert_allclose(test, vals, rtol=rtol) + + +def test_S121l2051(): + for N, vals in zip(testN, refvals["S121l2051"]): + S1 = harmonics.harmonic_S1(N) + H23 = hf.H23(N, S1) + test = csf.S121l2051(N, S1, H23) + np.testing.assert_allclose(test, vals, rtol=15e-01) + + +# TODO: still on going +# def test_S121l2105(): +# for N, vals in zip(testN, refvals["S121l2105"]): +# S1 = harmonics.harmonic_S1(N) +# S2 = harmonics.harmonic_S2(N) +# test = csf.S121l2105(N, S1, S2,H23,H25) +# np.testing.assert_allclose(test, vals), rtol=2e-05) + + +def test_S13l205(): + for N, vals in zip(testN, refvals["S13l205"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + S3 = harmonics.harmonic_S3(N) + test = csf.S13l205(N, S1, S2, S3) + np.testing.assert_allclose(test, vals, rtol=3e-03) + + +# not given alone +# def test_S211l2051(): +# for N, vals in zip(testNinteger, refvalsinteger["S211l2051"]): +# S1 = harmonics.harmonic_S1(N) +# S2 = harmonics.harmonic_S2(N) +# test = csf.S211l2051(N,S1,S2) +# np.testing.assert_allclose(test, vals, rtol=1e-03) +# for N, vals in zip(testN, refvals["S211l2051"]): +# S1 = harmonics.harmonic_S1(N) +# S2 = harmonics.harmonic_S2(N) +# test = csf.S211l2051(N,S1,S2) +# # same as S3l2 for complex part +# np.testing.assert_allclose(np.real(test), np.real(vals), rtol=1e-03) + +# not given alone +# def test_S211l2105(): +# for N, vals in zip(testN, refvals["S211l2105"]): +# S1 = harmonics.harmonic_S1(N) +# S2 = harmonics.harmonic_S2(N) +# test = csf.S211l2105(N, S1, S2) +# if N == 100 + 5j: +# continue +# np.testing.assert_allclose(test, vals, rtol=2e-02) + +# not given alone +# def test_S22l205(): +# for N, vals in zip(testN, refvals["S22l205"]): +# S1 = harmonics.harmonic_S1(N) +# S2 = harmonics.harmonic_S2(N) +# test = csf.S22l205(N, S1, S2) +# np.testing.assert_allclose(test, vals, rtol=1e-04) + + +def test_S31l205(): + for N, vals in zip(testN, refvals["S31l205"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + S3 = harmonics.harmonic_S3(N) + test = csf.S31l205(N, S1, S2, S3) + # same as S3l2 for complex part + np.testing.assert_allclose(np.real(test), np.real(vals), rtol=1e-04) + + +def test_S211l2051_S211l2105_S22l205(): + for N, vals in zip( + testN, + np.array(refvals["S211l2051"]) + + np.array(refvals["S211l2105"]) + - np.array(refvals["S22l205"]), + ): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + test = hf.H26(N, S1, S2) + rtol = 2e-02 + if N == 5j + 100: + rtol = 25e-01 + np.testing.assert_allclose(test, vals, rtol=rtol) From 14100dbf194b6da1b4cd80b9910eaaf458b58017 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Wed, 29 Sep 2021 14:13:44 +0200 Subject: [PATCH 35/71] Replacing some harmonics with a linear combination --- .../matching_conditions/n3lo/cs_functions.py | 920 ------------------ .../matching_conditions/n3lo/h_functions.py | 581 ++++++++++- .../matching_conditions/n3lo/s_functions.py | 8 +- tests/test_cs_functions.py | 69 +- 4 files changed, 633 insertions(+), 945 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/cs_functions.py b/src/eko/matching_conditions/n3lo/cs_functions.py index fdfdb8a0b..cb96293dd 100644 --- a/src/eko/matching_conditions/n3lo/cs_functions.py +++ b/src/eko/matching_conditions/n3lo/cs_functions.py @@ -59,769 +59,7 @@ def S1l05(n): return complex(ln2 - 1.0 * mp.betainc(1.0 + n, 0.0, x2=0.5)) -# @nb.njit("c16(c16,c16,c16, c16,c16)", cache=True) -def S121l2105(n, S1, S2, H23, H25): - return complex( - 0.041666666666666664 - * ( - 8.718466787621855 - - 13.9737726351603 * H23 - - 33.27106466687737 * H25 - + 2.9999999999999996 / (3.0 + n) - + 4.249999999999999 / (4.0 + n) - + 4.760416666666666 / (5.0 + n) - + 4.973958333333333 / (6.0 + n) - + 5.065434027777777 / (7.0 + n) - + 5.105381944444444 / (8.0 + n) - + 5.137736900800947 * S1 - - 5.123098316149376 - * ( - ( - 4.0 - * (9.0 + 2.0 * n) - * ( - 3044.0 - + 5886.0 * n - + 4299.0 * np.power(n, 2) - + 1539.0 * np.power(n, 3) - + 288.0 * np.power(n, 4) - + 27.0 * np.power(n, 5) - + np.power(n, 6) - ) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + S1 - ) - + ( - -4.508315233733057e-9 - - 2.0075627335735142e7 * S1 - + np.power(n, 4) - * ( - 8.34080933039605e8 - - 5.27949188465133e8 * S1 - - 6.269810033052008e8 * S2 - ) - + np.power(n, 3) - * ( - 6.68725912090791e8 - - 4.985280158146429e8 * S1 - - 5.920410569053438e8 * S2 - ) - + np.power(n, 5) - * ( - 6.970075838123745e8 - - 3.955620440258531e8 * S1 - - 4.6976090247208434e8 * S2 - ) - + np.power(n, 2) - * ( - 3.220716119130001e8 - - 3.1445681939854693e8 * S1 - - 3.7344209713788414e8 * S2 - ) - + np.power(n, 6) - * ( - 4.1200442264028406e8 - - 2.1646696206675032e8 * S1 - - 2.5707146828582215e8 * S2 - ) - + n - * ( - 7.04043541297633e7 - - 1.1844620128083734e8 * S1 - - 1.4066413916204685e8 * S2 - ) - + np.power(n, 7) - * ( - 1.7720686833255962e8 - - 8.798070100233266e7 * S1 - - 1.0448397192598484e8 * S2 - ) - + np.power(n, 8) - * ( - 5.615076052598522e7 - - 2.671201824728946e7 * S1 - - 3.1722613400888775e7 * S2 - ) - + np.power(n, 9) - * ( - 1.3108506526779806e7 - - 6.03389941621764e6 * S1 - - 7.165728052014327e6 * S2 - ) - + np.power(n, 10) - * ( - 2.227101326786286e6 - - 999008.3708972329 * S1 - - 1.1864006695727834e6 * S2 - ) - + np.power(n, 11) - * ( - 267716.88479469996 - - 117649.99198681205 * S1 - - 139718.5782768029 * S2 - ) - + np.power(n, 12) - * (21568.39562370471 - 9323.316514425609 * S1 - 11072.168439809184 * S2) - + np.power(n, 13) - * (1044.148599842857 - 445.3505292456677 * S1 - 528.8886274467523 * S2) - + np.power(n, 14) - * (22.94882997174772 - 9.681533244471037 * S1 - 11.497578857538095 * S2) - - 2.384137951899099e7 * S2 - ) - / ( - np.power(1.0 + n, 2) - * np.power(2.0 + n, 4) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - ) - + (complex(0.0, 16.14067650363345) * np.cos(3.141592653589793 * n)) - / np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) - + ( - 16.14067650363345 - * np.cos(3.141592653589793 * n) - * 1 - / np.tan(3.141592653589793 * n) - ) - / np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) - + ( - 3.2349177543783325 - * np.power(2.0, n) - * np.cos(3.141592653589793 * n) - * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) - ) - / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) - - ( - 0.33302465198892944 - * np.power(2.0, 1.0 + n) - * np.cos(3.141592653589793 * n) - * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) - ) - / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) - + ( - complex(0.0, 3.2349177543783325) - * np.power(2.0, n) - * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) - * np.sin(3.141592653589793 * n) - ) - / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) - - ( - complex(0.0, 0.33302465198892944) - * np.power(2.0, 1.0 + n) - * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) - * np.sin(3.141592653589793 * n) - ) - / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) - ) - ) - - -# @nb.njit("c16(c16,c16,c16,c16,c16)", cache=True) -def S112l2105(n, S1, S2, H21, H23): - return complex( - 0.020833333333333332 - * ( - -27.9475452703206 * (H21 + H23) - - 14.823618004648024 * S1 - + ( - -0.9260288995236766 - + 1.75595385252132e15 * S1 - + 1.3651603815024e15 * S2 - + np.power(n, 22) - * ( - -40.27318148695487 - + 14.816462392378826 * S1 - + 11.519008556547618 * S2 - ) - + np.power(n, 21) - * ( - -4632.295480386484 - + 1718.7096375159438 * S1 - + 1336.2049925595238 * S2 - ) - + np.power(n, 20) - * (-250567.9539452148 + 93847.47279332748 * S1 + 72961.40019717262 * S2) - + np.power(n, 19) - * ( - -8.474231929409903e6 - + 3.207467778702168e6 * S1 - + 2.4936349723214284e6 * S2 - ) - + np.power(n, 18) - * ( - -2.0095959944770676e8 - + 7.696309156130673e7 * S1 - + 5.98346951353962e7 * S2 - ) - + np.power(n, 17) - * ( - -3.5519950582077947e9 - + 1.3784542606770802e9 * S1 - + 1.0716746010651115e9 * S2 - ) - + np.power(n, 16) - * ( - -4.8556219898933846e10 - + 1.912722298960369e10 * S1 - + 1.4870394797719671e10 * S2 - ) - + np.power(n, 15) - * ( - -5.257581875674014e11 - + 2.106450745096599e11 * S1 - + 1.6376530047546756e11 * S2 - ) - + np.power(n, 14) - * ( - -4.580741130988878e12 - + 1.8710790245760586e12 * S1 - + 1.4546640569988308e12 * S2 - ) - + np.power(n, 13) - * ( - -3.244334123292615e13 - + 1.3549062415003168e13 * S1 - + 1.0533672732291225e13 * S2 - ) - + np.power(n, 12) - * ( - -1.8792319567508488e14 - + 8.051686163954172e13 * S1 - + 6.259756165880115e13 * S2 - ) - + np.power(n, 11) - * ( - -8.925629770015451e14 - + 3.94003621424455e14 * S1 - + 3.063167823942602e14 * S2 - ) - + np.power(n, 10) - * ( - -3.474511315485193e15 - + 1.5885028238122522e15 * S1 - + 1.2349761457907358e15 * S2 - ) - + np.power(n, 9) - * ( - -1.1045643145500984e16 - + 5.265033861267008e15 * S1 - + 4.093282761588436e15 * S2 - ) - + n - * ( - -5.427466825742352e15 - + 1.145690208061728e16 * S1 - + 8.907129758993039e15 * S2 - ) - + np.power(n, 8) - * ( - -2.8476622260833744e16 - + 1.4273882811710074e16 * S1 - + 1.1097181897334674e16 * S2 - ) - + np.power(n, 7) - * ( - -5.887543943227375e16 - + 3.1389184218177224e16 * S1 - + 2.440341506743307e16 * S2 - ) - + np.power(n, 2) - * ( - -2.9025585004552024e16 - + 3.4459443241488012e16 * S1 - + 2.6790377557111176e16 * S2 - ) - + np.power(n, 6) - * ( - -9.599855549416707e16 - + 5.529627361997772e16 * S1 - + 4.298990083498981e16 * S2 - ) - + np.power(n, 3) - * ( - -7.2360160718216e16 - + 6.370427756808302e16 * S1 - + 4.95266750565833e16 * S2 - ) - + np.power(n, 5) - * ( - -1.2041907301754731e17 - + 7.66394296991267e16 * S1 - + 5.958306531573035e16 * S2 - ) - + np.power(n, 4) - * ( - -1.118794246274288e17 - + 8.14061286433952e16 * S1 - + 6.328891928217773e16 * S2 - ) - ) - / ( - np.power(1.0 + n, 2) - * np.power(2.0 + n, 2) - * np.power(3.0 + n, 4) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - * np.power(10.0 + n, 2) - ) - + ( - 13.9737726351603 - * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) - * ( - 2.0 - * ( - -0.6931471805599453 * np.power(2.0, n) - + H23 * n - + 0.6931471805599453 * n * S1 - + 2.177586090303602 * n * 1 / np.tan(3.141592653589793 * n) - ) - + 0.6931471805599453 - * np.power(2.0, n) - * n - * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n) - ) - * np.sin(3.141592653589793 * n) - ) - / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) - - ( - 7.411809002324012 - * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) - * ( - 6.283185307179586 * n * np.cos(3.141592653589793 * n) - + np.power(2.0, n) - * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) - * np.sin(3.141592653589793 * n) - ) - ) - / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) - ) - ) - - -# @nb.njit("c16(c16,c16,c16)", cache=True) -def S211l2105(n, S1, S2): - return complex( - 0.041666666666666664 - * ( - complex(26.40764917447151, 30.42909291939018) - - (19.351524467966858 * np.power(2.0, n)) / (1.0 + n) - - (6.262726309306497 * np.power(2.0, n)) / (2.0 + n) - - 0.7343749999999999 / (3.0 + n) - + (12.00212909720108 * np.power(2.0, n)) / (3.0 + n) - - 0.23437499999999994 / (4.0 + n) - - (172.2163955321142 * np.power(2.0, n)) / (4.0 + n) - - 0.0625 / (5.0 + n) - + (1405.5398464455116 * np.power(2.0, n)) / (5.0 + n) - - (8703.997977574893 * np.power(2.0, n)) / (6.0 + n) - + (41928.01774475129 * np.power(2.0, n)) / (7.0 + n) - - (160951.91817594544 * np.power(2.0, n)) / (8.0 + n) - + (499634.153549029 * np.power(2.0, n)) / (9.0 + n) - - (1.2654327397059284e6 * np.power(2.0, n)) / (10.0 + n) - + (2.6260030398488953e6 * np.power(2.0, n)) / (11.0 + n) - - (4.465586330056064e6 * np.power(2.0, n)) / (12.0 + n) - + (6.198176978342689e6 * np.power(2.0, n)) / (13.0 + n) - - (6.961720352934347e6 * np.power(2.0, n)) / (14.0 + n) - + (6.236645257147073e6 * np.power(2.0, n)) / (15.0 + n) - - (4.355777195115037e6 * np.power(2.0, n)) / (16.0 + n) - + (2.287718942232814e6 * np.power(2.0, n)) / (17.0 + n) - - (850756.7344439693 * np.power(2.0, n)) / (18.0 + n) - + (199917.59252552615 * np.power(2.0, n)) / (19.0 + n) - - (22348.960043583 * np.power(2.0, n)) / (20.0 + n) - - 7.411809002324012 * S1 - - 2.234375 - * ( - -0.5772156649015329 - - 1.0 / (3.0 + n) - + (11.0 + 12.0 * n + 3.0 * np.power(n, 2)) - / (6.0 + 11.0 * n + 6.0 * np.power(n, 2) + np.power(n, 3)) - + S1 - ) - + ( - 2301.0054569785552 - + 2.3564799588509725e19 * S1 - + np.power(n, 21) * (-10.512601395041514 + 9.685881103847077 * S1) - + np.power(n, 20) * (-2206.628022019722 + 2043.7209129117334 * S1) - + np.power(n, 19) * (-216505.99319159146 + 201708.47398761538 * S1) - + np.power(n, 18) * (-1.3192300150519693e7 + 1.2373374104326006e7 * S1) - + np.power(n, 17) * (-5.593867445718834e8 + 5.287018441337475e8 * S1) - + np.power(n, 16) * (-1.752878291455452e10 + 1.6714041339232273e10 * S1) - + np.power(n, 15) * (-4.207344725909635e11 + 4.05296516933841e11 * S1) - + np.power(n, 14) * (-7.911700211293982e12 + 7.712702038095058e12 * S1) - + np.power(n, 13) * (-1.182221056152559e14 + 1.168736012631931e14 * S1) - + np.power(n, 12) - * (-1.4155108114396065e15 + 1.4228119592370445e15 * S1) - + np.power(n, 11) * (-1.363175581264904e16 + 1.3977890612219908e16 * S1) - + np.power(n, 10) * (-1.0556974421987099e17 + 1.109017392681198e17 * S1) - + np.power(n, 9) * (-6.548610450489597e17 + 7.087460624896044e17 * S1) - + np.power(n, 8) * (-3.227614926711552e18 + 3.6260496031614787e18 * S1) - + np.power(n, 7) * (-1.2477695102045143e19 + 1.4702987812923677e19 * S1) - + np.power(n, 6) * (-3.711573495044675e19 + 4.655642074876013e19 * S1) - + n * (-2.4500394557497614e19 + 1.0834481358073427e20 * S1) - + np.power(n, 5) * (-8.257880390369016e19 + 1.1272226323636158e20 * S1) - + np.power(n, 4) * (-1.3168723078804224e20 + 2.025195993855592e20 * S1) - + np.power(n, 2) * (-8.864030957300654e19 + 2.184815897520579e20 * S1) - + np.power(n, 3) * (-1.4055237841498638e20 + 2.583678854961562e20 * S1) - ) - / ( - np.power(1.0 + n, 2) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - * (16.0 + n) - * (17.0 + n) - * (18.0 + n) - * (19.0 + n) - * (20.0 + n) - ) - + 5.765436167018416 * S2 - - 4.528162976761489 - * ( - 9.42477796076938 - + 1 - / np.tan(3.141592653589793 * n) - * ( - 2.772588722239781 - + 12.566370614359172 * 1 / np.tan(3.141592653589793 * n) - ) - ) - + 1.441359041754604 - * np.power(2.0, 2.0 + n) - * mp.lerchphi(0.5, 2.0, -1.0 * n) - - 2.882718083509208 - * ( - -3.141592653589793 - * ( - 9.42477796076938 - + 1 - / np.tan(3.141592653589793 * n) - * ( - 2.772588722239781 - + 12.566370614359172 * 1 / np.tan(3.141592653589793 * n) - ) - ) - + np.power(2.0, 2.0 + n) * mp.lerchphi(0.5, 2.0, -1.0 * n) - ) - + ( - 19.371762207694154 - * np.power(2.0, n) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / (1.0 + n) - + 27.36435385542846 - * ( - S1 - + n * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) - ) - ) - ) - - -# @nb.njit("c16(c16)", cache=True) -def S12l21(H25): - return complex(-2.0 * H25) - - # @nb.njit("c16(c16,c16,c16,c16)", cache=True) -def S13l205(n, S1, S2, S3): - return complex( - 0.020833333333333332 - * ( - -35.91351656957576 - - 24.94558274872449 / np.power(2.0 + n, 2) - + 0.1875 / np.power(4.0 + n, 2) - + 0.046875 / (4.0 + n) - + 0.020833333333333332 / np.power(6.0 + n, 2) - + 0.003472222222222222 / (6.0 + n) - + 0.0029296875 / np.power(8.0 + n, 2) - + 0.0003662109375 / (8.0 + n) - + 1.5 / (2.0 + 1.0 * n) - + (27.94558274872449 * (5.0 + 6.0 * n + 2.0 * np.power(n, 2))) - / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) - + 0.8541666666666666 * (np.power(2.0 + n, -2) + np.power(3.0 + n, -2)) - + 0.2690972222222222 * (1 / (2.0 + n) + 1 / (3.0 + n)) - + 0.09141608205782313 - * ( - np.power(2.0 + n, -2) - + np.power(3.0 + n, -2) - + np.power(4.0 + n, -2) - + np.power(5.0 + n, -2) - ) - + 0.016931727620363622 - * (1 / (2.0 + n) + 1 / (3.0 + n) + 1 / (4.0 + n) + 1 / (5.0 + n)) - + 0.010582748724489796 * (np.power(6.0 + n, -2) + np.power(7.0 + n, -2)) - + 0.0014595053981413995 * (1 / (6.0 + n) + 1 / (7.0 + n)) - - 25.78623329318593 * S1 - + 25.786028949842585 - * ( - -0.5772156649015329 - - 1.0 / (2.0 + n) - + (3.0 + 2.0 * n) / (2.0 + 3.0 * n + np.power(n, 2)) - + S1 - ) - + 27.94558274872449 * S2 - - ( - 6.0 - * ( - -9.0 - - 15.0 * n - - 9.0 * np.power(n, 2) - - 2.0 * np.power(n, 3) - - 1.0 - * np.power(2.0 + 3.0 * n + np.power(n, 2), 3) - * (-1.2020569031595945 + S3) - ) - ) - / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) - - ( - 2.0 - * ( - -251.0 - - 684.0 * n - - 795.0 * np.power(n, 2) - - 504.0 * np.power(n, 3) - - 183.0 * np.power(n, 4) - - 36.0 * np.power(n, 5) - - 3.0 * np.power(n, 6) - - 1.0 - * np.power( - 6.0 + 11.0 * n + 6.0 * np.power(n, 2) + np.power(n, 3), 3 - ) - * (-1.2020569031595945 + S3) - ) - ) - / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3) * np.power(3.0 + n, 3)) - + ( - 0.375 - * ( - 32560.0 - + 114024.0 * n - + 179100.0 * np.power(n, 2) - + 165380.0 * np.power(n, 3) - + 98700.0 * np.power(n, 4) - + 39396.0 * np.power(n, 5) - + 10500.0 * np.power(n, 6) - + 1800.0 * np.power(n, 7) - + 180.0 * np.power(n, 8) - + 8.0 * np.power(n, 9) - + 2.0 - * np.power( - 24.0 - + 50.0 * n - + 35.0 * np.power(n, 2) - + 10.0 * np.power(n, 3) - + np.power(n, 4), - 3, - ) - * (-1.2020569031595945 + S3) - ) - ) - / ( - np.power(1.0 + n, 3) - * np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - ) - + 0.30000000000000004 - * ( - -1.0 / np.power(6.0 + n, 3) - + ( - (7.0 + 2.0 * n) - * ( - 6.3467712e7 - + 2.75413824e8 * n - + 5.54256432e8 * np.power(n, 2) - + 6.84826352e8 * np.power(n, 3) - + 5.79544028e8 * np.power(n, 4) - + 3.54873092e8 * np.power(n, 5) - + 1.61970683e8 * np.power(n, 6) - + 5.5932611e7 * np.power(n, 7) - + 1.4676674e7 * np.power(n, 8) - + 2.911041e6 * np.power(n, 9) - + 429534.0 * np.power(n, 10) - + 45717.0 * np.power(n, 11) - + 3318.0 * np.power(n, 12) - + 147.0 * np.power(n, 13) - + 3.0 * np.power(n, 14) - ) - ) - / ( - np.power(1.0 + n, 3) - * np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - ) - + S3 - ) - + ( - -4.849365675830262 - + 24.0 * S3 - + np.power(n, 3) * (-28.849365675830263 + 24.0 * S3) - + n * (-86.5480970274908 + 72.0 * S3) - + np.power(n, 2) * (-86.5480970274908 + 72.0 * S3) - ) - / np.power(1.0 + n, 3) - + ( - -1.8827917371821213e8 - + np.power(n, 21) * (-0.15025711289494928 + 0.125 * S3) - + 1.6003008e10 * S3 - + np.power(n, 20) * (-12.621597483175739 + 10.5 * S3) - + np.power(n, 19) * (-498.5531005854417 + 414.75 * S3) - + np.power(n, 18) * (-12309.514745257404 + 10241.0 * S3) - + np.power(n, 17) * (-213006.90671411887 + 177247.875 * S3) - + np.power(n, 16) * (-2.745208063810683e6 + 2.2853355e6 * S3) - + np.power(n, 15) * (-2.7333790694426738e7 + 2.2772873e7 * S3) - + np.power(n, 14) * (-2.1525719333960438e8 + 1.79575452e8 * S3) - + np.power(n, 13) * (-1.3613819668701482e9 + 1.138062751875e9 * S3) - + np.power(n, 12) * (-6.981325709004752e9 + 5.8543813055e9 * S3) - + np.power(n, 11) * (-2.918265095349929e10 + 2.458519389375e10 * S3) - + np.power(n, 10) * (-9.959730967499185e10 + 8.4473879133e10 * S3) - + n * (-5.3368228689679504e10 + 1.244805408e11 * S3) - + np.power(n, 9) * (-2.7702671731906366e11 + 2.37268950102125e11 * S3) - + np.power(n, 2) * (-3.0945500345609973e11 + 4.4785043856e11 * S3) - + np.power(n, 8) * (-6.245882034204874e11 + 5.425955373405e11 * S3) - + np.power(n, 3) * (-8.52658888324106e11 + 9.92117796984e11 * S3) - + np.power(n, 7) * (-1.1304998617813767e12 + 1.0026916293345e12 * S3) - + np.power(n, 6) * (-1.6179236885848447e12 + 1.479872994614e12 * S3) - + np.power(n, 4) * (-1.4740504277291758e12 + 1.519937938008e12 * S3) - + np.power(n, 5) * (-1.7889236321409622e12 + 1.714464923598e12 * S3) - ) - / ( - np.power(1.0 + n, 3) - * np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - ) - + ( - -3.1076170690167686e10 - + np.power(n, 24) * (-0.06439590552640682 + 0.05357142857142857 * S3) - + 3.511517184e12 * S3 - + np.power(n, 23) * (-6.954757796851938 + 5.785714285714286 * S3) - + np.power(n, 22) * (-355.85177393892417 + 296.0357142857143 * S3) - + np.power(n, 21) * (-11474.975364805698 + 9546.42857142857 * S3) - + np.power(n, 20) * (-261689.50235318032 + 217731.375 * S3) - + np.power(n, 19) * (-4.489549647230873e6 + 3.7362465e6 * S3) - + np.power(n, 18) * (-6.0174545299099594e7 + 5.009824671428571e7 * S3) - + np.power(n, 17) * (-6.459454766764826e8 + 5.381398851428571e8 * S3) - + np.power(n, 16) * (-5.647936378402138e9 + 4.710152996517857e9 * S3) - + np.power(n, 15) * (-4.06934872365595e10 + 3.3988322190214283e10 * S3) - + np.power(n, 14) * (-2.434761228276682e11 + 2.0380329643275e11 * S3) - + np.power(n, 13) * (-1.2154258996820479e12 + 1.020534802371e12 * S3) - + np.power(n, 12) * (-5.07315542830191e12 + 4.2781896451329106e12 * S3) - + np.power(n, 11) * (-1.770226596040418e13 + 1.5018709031540355e13 * S3) - + n * (-1.1646920948258486e13 + 2.86314061824e13 * S3) - + np.power(n, 10) * (-5.151048207445098e13 + 4.407053531194735e13 * S3) - + np.power(n, 9) * (-1.2436603267566345e14 + 1.0765907902298828e14 * S3) - + np.power(n, 2) * (-7.201432181343031e13 + 1.0867875452928e14 * S3) - + np.power(n, 8) * (-2.4716507853081303e14 + 2.17524482033526e14 * S3) - + np.power(n, 3) * (-2.1249044478604434e14 + 2.5583791381994056e14 * S3) - + np.power(n, 7) * (-3.99629094081214e14 + 3.60077496552648e14 * S3) - + np.power(n, 4) * (-3.9587554959384794e14 + 4.198147424345417e14 * S3) - + np.power(n, 6) * (-5.168531019972349e14 + 4.8186122866386856e14 * S3) - + np.power(n, 5) * (-5.216872802515547e14 + 5.116683439482377e14 * S3) - ) - / ( - np.power(1.0 + n, 3) - * np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - ) - + ( - -7.7239450334953125e12 - + np.power(n, 27) * (-0.02817320866780299 + 0.0234375 * S3) - + 1.119954511872e15 * S3 - + np.power(n, 26) * (-3.8033831701534035 + 3.1640625 * S3) - + np.power(n, 25) * (-244.68431727986894 + 203.5546875 * S3) - + np.power(n, 24) * (-9983.693321652685 + 8305.6640625 * S3) - + np.power(n, 23) * (-290084.326995499 + 241342.2421875 * S3) - + np.power(n, 22) * (-6.3886763936445005e6 + 5.3158812890625e6 * S3) - + np.power(n, 21) * (-1.1083531859904346e8 + 9.22446755859375e7 * S3) - + np.power(n, 20) * (-1.5540653936148872e9 + 1.2938741455078125e9 * S3) - + np.power(n, 19) - * (-1.7928546082039547e10 + 1.4935168301132812e10 * S3) - + np.power(n, 18) - * (-1.7235833156872174e11 + 1.4369777933027344e11 * S3) - + np.power(n, 17) * (-1.3933977821809019e12 + 1.163032128121289e12 * S3) - + np.power(n, 16) * (-9.532903149222146e12 + 7.969538339323242e12 * S3) - + np.power(n, 15) * (-5.5421804520716875e13 + 4.643376378330129e13 * S3) - + np.power(n, 14) - * (-2.7442937550584856e14 + 2.3060292041751853e14 * S3) - + np.power(n, 13) * (-1.1580659863189835e15 + 9.770012148134408e14 * S3) - + np.power(n, 12) * (-4.1604768475468305e15 + 3.528835659305147e15 * S3) - + n * (-3.7001995643590905e15 + 9.5049472799232e15 * S3) - + np.power(n, 11) - * (-1.2690820817593494e16 + 1.0842168128947024e16 * S3) - + np.power(n, 10) - * (-3.2719471459776132e16 + 2.8228294043448464e16 * S3) - + np.power(n, 2) * (-2.4139679917260076e16 + 3.774708643918464e16 * S3) - + np.power(n, 9) * (-7.082596355241246e16 + 6.192631872765216e16 * S3) - + np.power(n, 3) * (-7.540813820098134e16 + 9.348995950413898e16 * S3) - + np.power(n, 8) * (-1.2752168126680246e17 + 1.135732940048904e17 * S3) - + np.power(n, 4) * (-1.4945046274726707e17 + 1.62389726656281e17 * S3) - + np.power(n, 7) * (-1.8852682955808618e17 + 1.7229783969179136e17 * S3) - + np.power(n, 5) * (-2.107050012914055e17 + 2.108914095651679e17 * S3) - + np.power(n, 6) * (-2.2478668354322694e17 + 2.1315134716528384e17 * S3) - ) - / ( - np.power(1.0 + n, 3) - * np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) - ) - - ( - 12.893116646592965 - * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) - * ( - 6.283185307179586 * n * np.cos(3.141592653589793 * n) - + np.power(2.0, n) - * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) - * np.sin(3.141592653589793 * n) - ) - ) - / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) - ) - ) - - def S31l205(n, S1, S2, S3): # HarmonicNumber[5. +N] Snp5 = (274 + 450 * n + 255 * n ** 2 + 60 * n ** 3 + 5 * n ** 4) / ( @@ -1144,108 +382,6 @@ def S21l21(n, S1): ) -# @nb.njit("c16(c16,c16,c16, c16,c16)", cache=True) -def S1111l21105(n, S1, H21, H23, H24): - return complex( - 0.08333333333333333 - * ( - -2.882718083509208 * (H21 + H23) - + 8.317766166719343 * H24 - - 0.6660493039778589 * S1 - + ( - -21.28497824694114 - + np.power(n, 22) * (-1.4032651231697697 + 0.6651555702169106 * S1) - + 3.306657872663145e17 * S1 - + np.power(n, 21) * (-225.8619793647119 + 108.42035794535643 * S1) - + np.power(n, 20) * (-17161.340432724224 + 8352.358495213746 * S1) - + np.power(n, 19) * (-818456.95859745 + 404404.6093583284 * S1) - + np.power(n, 18) * (-2.7478728153544266e7 + 1.380478237788493e7 * S1) - + np.power(n, 17) * (-6.904019105536251e8 + 3.5325744384996516e8 * S1) - + np.power(n, 16) * (-1.3470591633763092e10 + 7.033776682829219e9 * S1) - + np.power(n, 15) - * (-2.0903754546392337e11 + 1.1164307832844762e11 * S1) - + np.power(n, 14) - * (-2.6209568351289272e12 + 1.4356036433688328e12 * S1) - + np.power(n, 13) * (-2.68237465524399e13 + 1.5115872138017662e13 * S1) - + np.power(n, 12) * (-2.254287456569634e14 + 1.311899520263152e14 * S1) - + np.power(n, 11) * (-1.5596729430294308e15 + 9.416388908315981e14 * S1) - + np.power(n, 10) * (-8.878314402636898e15 + 5.592104439069029e15 * S1) - + np.power(n, 9) * (-4.142544242067615e16 + 2.7412580442697824e16 * S1) - + np.power(n, 8) * (-1.5728620543904387e17 + 1.1033207871178562e17 * S1) - + np.power(n, 7) * (-4.8039406140988416e17 + 3.614468871513744e17 * S1) - + np.power(n, 6) * (-1.1601637307682578e18 + 9.513458515809779e17 * S1) - + n * (-4.7010131790074784e17 + 1.4714664237290086e18 * S1) - + np.power(n, 5) * (-2.1596907094790292e18 + 1.9743867729749857e18 * S1) - + np.power(n, 2) * (-1.7031784220857746e18 + 2.980594864657508e18 * S1) - + np.power(n, 4) * (-2.9809599710714127e18 + 3.143983341049741e18 * S1) - + np.power(n, 3) * (-2.8638554267864535e18 + 3.686977129250879e18 * S1) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - * np.power(10.0 + n, 2) - * np.power(11.0 + n, 2) - * np.power(12.0 + n, 2) - * (13.0 + n) - ) - - ( - 2.0794415416798357 - * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) - * ( - 2.0 - * ( - -0.4804530139182014 * np.power(2.0, n) - - 1.3862943611198906 * H21 * n - + 2.0 * H22 * n - + 0.4804530139182014 * n * S1 - + 1.5093876589204962 * n * 1 / np.tan(3.141592653589793 * n) - ) - + 0.4804530139182014 - * np.power(2.0, n) - * n - * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n) - ) - * np.sin(3.141592653589793 * n) - ) - / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) - - ( - 0.33302465198892944 - * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) - * ( - 6.283185307179586 * n * np.cos(3.141592653589793 * n) - + np.power(2.0, n) - * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) - * np.sin(3.141592653589793 * n) - ) - ) - / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) - + 1.441359041754604 - * ( - 2.0 * H23 - + 1.3862943611198906 * S1 - + ( - 0.6931471805599453 - * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) - * ( - 6.283185307179586 * n * np.cos(3.141592653589793 * n) - + np.power(2.0, n) - * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) - * np.sin(3.141592653589793 * n) - ) - ) - / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) - ) - ) - ) - - # @nb.njit("c16(c16,c16,c16)", cache=True) def S1111l21051(n, S1, H21): return complex( @@ -1369,59 +505,3 @@ def S3l2(n): return complex( 2.0 * ((1.38104 - 0.377347j) - 2 ** n * mp.lerchphi(2.0, 3.0, 1.0 + n)) ) - - -# @nb.njit("c16(c16,c16)", cache=True) -def S112l2051(n, S1): - return complex( - -0.7512855644747464 * S1 - + ( - -0.00009170966363217119 - + np.power(n, 16) * (-1.1551344276377544 + 0.7512855644747464 * S1) - + 9.824368757120372e11 * S1 - + np.power(n, 15) * (-138.12633167732008 + 90.90555330144431 * S1) - + np.power(n, 14) * (-7543.3310441845915 + 5033.6132819808 * S1) - + np.power(n, 13) * (-249212.9318573135 + 169024.22629552844 * S1) - + np.power(n, 12) * (-5.5609596917238e6 + 3.8450960472641704e6 * S1) - + np.power(n, 11) * (-8.860864646926463e7 + 6.270086727106097e7 * S1) - + np.power(n, 10) * (-1.0392528981358187e9 + 7.562847839035856e8 * S1) - + np.power(n, 9) * (-9.112653779990723e9 + 6.863537366891241e9 * S1) - + np.power(n, 8) * (-6.0048063053520065e10 + 4.7209851439097336e10 * S1) - + np.power(n, 7) * (-2.962939969277478e11 + 2.4599669313036557e11 * S1) - + np.power(n, 6) * (-1.0811050344017815e12 + 9.635051930282513e11 * S1) - + np.power(n, 5) * (-2.849355344696549e12 + 2.792141871178878e12 * S1) - + n * (-1.2515090782257412e12 + 4.242387400717028e12 * S1) - + np.power(n, 4) * (-5.216229253731701e12 + 5.832837664170654e12 * S1) - + np.power(n, 2) * (-4.2583318206830425e12 + 7.892240292128241e12 * S1) - + np.power(n, 3) * (-6.210399061644802e12 + 8.43153763901703e12 * S1) - ) - / ( - np.power(1.0 + n, 2) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - ( - 0.3756427822373732 - * (complex(0.0, 1.0) + 1 / np.tan(3.141592653589793 * n)) - * ( - 6.283185307179586 * n * np.cos(3.141592653589793 * n) - + np.power(2.0, n) - * (-2.0 + n * mp.lerchphi(0.5, 1.0, 1.0 - 1.0 * n)) - * np.sin(3.141592653589793 * n) - ) - ) - / (np.power(2.718281828459045, complex(0.0, 3.141592653589793) * n) * n) - ) - diff --git a/src/eko/matching_conditions/n3lo/h_functions.py b/src/eko/matching_conditions/n3lo/h_functions.py index 81b78736a..268797be8 100644 --- a/src/eko/matching_conditions/n3lo/h_functions.py +++ b/src/eko/matching_conditions/n3lo/h_functions.py @@ -123,7 +123,11 @@ def H21(n, S1): ) -# @nb.njit("c16(c16,c16)", cache=True) +def H22(): + return 0.0 + + +@nb.njit("c16(c16,c16)", cache=True) def H23(n, S1): r"""Mellin transform of :math:`\int_{0}^{1} (x^(n)-1)(ln(1-x/2))/(x-1)`""" return complex( @@ -146,6 +150,16 @@ def H23(n, S1): ) +# @nb.njit("c16()", cache=True) +def H24(): + return 0.0 + + +# @nb.njit("c16()", cache=True) +def H25(): + return 0.0 + + # @nb.njit("c16(c16,c16,c16)", cache=True) def H26(n, S1, S2): """Linear combination of S211l2051 + S211l2105 - S22l205""" @@ -403,3 +417,568 @@ def H26(n, S1, S2): * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) ) ) + + +# @nb.njit("c16(c16,c16,c16)", cache=True) +def H27(n, S1, S2, S3, H21, H22, H23, H24, H25): + """Linear combination of + S1111l21105 + S112l2051 - S112l2105 + S121l2105 - S13l205""" + return complex( + 0.125 + * ( + complex(0.0, -3.7763731361630786) + + 6.579736267392905 * H21 + - 5.545177444479562 * H22 + - 4.657924211720099 * H23 + + 5.545177444479562 * H24 + - 11.090354888959125 * H25 + + ( + np.power(n, 2) * (166512.82004488667 - 201720.28849894297 * S1) + + n * (90242.14129258736 - 187136.5352923044 * S1) + + np.power(n, 3) * (123906.8708531517 - 114900.84903459821 * S1) + + np.power(n, 4) * (48677.646427379485 - 38336.14469974578 * S1) + + np.power(n, 5) * (10981.454596417643 - 7746.124654017857 * S1) + + np.power(n, 6) * (1430.3006794295188 - 932.4038935391865 * S1) + + np.power(n, 7) * (100.01173626580466 - 61.477179793792516 * S1) + + np.power(n, 8) * (2.906155595873952 - 1.7076994387164588 * S1) + - 68854.44136904762 * S1 + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - 1.2020569031595942 * S1 + + ( + -0.0007336773090573695 + + 7.859495005696298e12 * S1 + + np.power(n, 16) * (-9.241075421102035 + 6.010284515797971 * S1) + + np.power(n, 15) * (-1105.0106534185607 + 727.2444264115545 * S1) + + np.power(n, 14) * (-60346.64835347673 + 40268.9062558464 * S1) + + np.power(n, 13) * (-1.993703454858508e6 + 1.3521938103642275e6 * S1) + + np.power(n, 12) * (-4.44876775337904e7 + 3.0760768378113363e7 * S1) + + np.power(n, 11) * (-7.08869171754117e8 + 5.016069381684878e8 * S1) + + np.power(n, 10) * (-8.31402318508655e9 + 6.050278271228684e9 * S1) + + np.power(n, 9) * (-7.290123023992578e10 + 5.490829893512993e10 * S1) + + np.power(n, 8) * (-4.803845044281605e11 + 3.776788115127787e11 * S1) + + np.power(n, 7) * (-2.3703519754219824e12 + 1.9679735450429246e12 * S1) + + np.power(n, 6) * (-8.648840275214252e12 + 7.708041544226011e12 * S1) + + np.power(n, 5) * (-2.279484275757239e13 + 2.2337134969431023e13 * S1) + + n * (-1.001207262580593e13 + 3.3939099205736223e13 * S1) + + np.power(n, 4) * (-4.172983402985361e13 + 4.6662701313365234e13 * S1) + + np.power(n, 2) * (-3.406665456546434e13 + 6.313792233702593e13 * S1) + + np.power(n, 3) * (-4.9683192493158414e13 + 6.745230111213624e13 * S1) + ) + / ( + np.power(1.0 + n, 2) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + ( + -99.32989848572531 + + np.power(n, 22) * (-0.9355100821131798 + 0.4434370468112737 * S1) + + 2.20443858177543e17 * S1 + + np.power(n, 21) * (-150.57465290980792 + 72.28023863023762 * S1) + + np.power(n, 20) * (-11440.89362181615 + 5568.238996809164 * S1) + + np.power(n, 19) * (-545637.9723982998 + 269603.0729055522 * S1) + + np.power(n, 18) * (-1.831915210236284e7 + 9.203188251923285e6 * S1) + + np.power(n, 17) * (-4.6026794036908334e8 + 2.355049625666434e8 * S1) + + np.power(n, 16) * (-8.980394422508726e9 + 4.689184455219479e9 * S1) + + np.power(n, 15) * (-1.3935836364261557e11 + 7.442871888563174e10 * S1) + + np.power(n, 14) * (-1.7473045567526182e12 + 9.570690955792218e11 * S1) + + np.power(n, 13) * (-1.788249770162659e13 + 1.0077248092011773e13 * S1) + + np.power(n, 12) * (-1.5028583043797556e14 + 8.745996801754348e13 * S1) + + np.power(n, 11) * (-1.0397819620196205e15 + 6.277592605543988e14 * S1) + + np.power(n, 10) * (-5.918876268424598e15 + 3.728069626046019e15 * S1) + + np.power(n, 9) * (-2.7616961613784108e16 + 1.827505362846522e16 * S1) + + np.power(n, 8) * (-1.0485747029269587e17 + 7.35547191411904e16 * S1) + + np.power(n, 7) * (-3.2026270760658944e17 + 2.4096459143424966e17 * S1) + + np.power(n, 6) * (-7.734424871788384e17 + 6.34230567720652e17 * S1) + + n * (-3.1340087860049805e17 + 9.809776158193391e17 * S1) + + np.power(n, 5) * (-1.4397938063193528e18 + 1.3162578486499904e18 * S1) + + np.power(n, 2) * (-1.1354522813905171e18 + 1.9870632431050053e18 * S1) + + np.power(n, 4) * (-1.9873066473809416e18 + 2.0959888940331604e18 * S1) + + np.power(n, 3) * (-1.9092369511909688e18 + 2.4579847528339195e18 * S1) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + * np.power(11.0 + n, 2) + * np.power(12.0 + n, 2) + * (13.0 + n) + ) + + ( + 0.0771690749603064 + - 2.9265897542022e14 * S1 + + np.power(n, 4) + * ( + 1.8646570771238136e16 + - 1.3567688107232536e16 * S1 + - 1.0548153213696288e16 * S2 + ) + + np.power(n, 5) + * ( + 2.006984550292455e16 + - 1.2773238283187784e16 * S1 + - 9.930510885955058e15 * S2 + ) + + np.power(n, 3) + * ( + 1.2060026786369336e16 + - 1.0617379594680504e16 * S1 + - 8.254445842763882e15 * S2 + ) + + np.power(n, 6) + * ( + 1.5999759249027844e16 + - 9.21604560332962e15 * S1 + - 7.164983472498301e15 * S2 + ) + + np.power(n, 2) + * ( + 4.837597500758669e15 + - 5.743240540248003e15 * S1 + - 4.4650629261851955e15 * S2 + ) + + np.power(n, 7) + * ( + 9.812573238712292e15 + - 5.231530703029538e15 * S1 + - 4.067235844572178e15 * S2 + ) + + np.power(n, 8) + * ( + 4.746103710138956e15 + - 2.3789804686183455e15 * S1 + - 1.8495303162224455e15 * S2 + ) + + n + * ( + 9.045778042903921e14 + - 1.9094836801028798e15 * S1 + - 1.48452162649884e15 * S2 + ) + + np.power(n, 9) + * ( + 1.840940524250164e15 + - 8.775056435445015e14 * S1 + - 6.822137935980728e14 * S2 + ) + + np.power(n, 10) + * ( + 5.790852192475322e14 + - 2.6475047063537547e14 * S1 + - 2.0582935763178938e14 * S2 + ) + + np.power(n, 11) + * ( + 1.4876049616692416e14 + - 6.566727023740917e13 * S1 + - 5.105279706571004e13 * S2 + ) + + np.power(n, 12) + * ( + 3.1320532612514152e13 + - 1.3419476939923623e13 * S1 + - 1.0432926943133523e13 * S2 + ) + + np.power(n, 13) + * ( + 5.407223538821024e12 + - 2.258177069167195e12 * S1 + - 1.7556121220485374e12 * S2 + ) + + np.power(n, 14) + * ( + 7.63456855164813e11 + - 3.118465040960098e11 * S1 + - 2.4244400949980518e11 * S2 + ) + + np.power(n, 15) + * ( + 8.762636459456693e10 + - 3.510751241827666e10 * S1 + - 2.729421674591126e10 * S2 + ) + + np.power(n, 16) + * ( + 8.092703316488976e9 + - 3.1878704982672825e9 * S1 + - 2.4783991329532785e9 * S2 + ) + + np.power(n, 17) + * ( + 5.919991763679658e8 + - 2.2974237677951336e8 * S1 + - 1.7861243351085195e8 * S2 + ) + + np.power(n, 18) + * ( + 3.3493266574617792e7 + - 1.2827181926884457e7 * S1 + - 9.9724491892327e6 * S2 + ) + + np.power(n, 19) + * ( + 1.4123719882349833e6 + - 534577.9631170281 * S1 + - 415605.82872023806 * S2 + ) + + np.power(n, 20) + * ( + 41761.32565753581 + - 15641.245465554583 * S1 + - 12160.233366195433 * S2 + ) + + np.power(n, 21) + * (772.0492467310804 - 286.4516062526573 * S1 - 222.70083209325392 * S2) + + np.power(n, 22) + * (6.712196914492478 - 2.4694103987298046 * S1 - 1.919834759424603 * S2) + - 2.2752673025039997e14 * S2 + ) + / ( + np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + * np.power(3.0 + n, 4) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + * np.power(7.0 + n, 2) + * np.power(8.0 + n, 2) + * np.power(9.0 + n, 2) + * np.power(10.0 + n, 2) + ) + + ( + -1.5027717445776854e-9 + - 6.69187577857838e6 * S1 + + np.power(n, 4) + * ( + 2.7802697767986834e8 + - 1.7598306282171097e8 * S1 + - 2.0899366776840028e8 * S2 + ) + + np.power(n, 3) + * ( + 2.2290863736359698e8 + - 1.6617600527154762e8 * S1 + - 1.9734701896844792e8 * S2 + ) + + np.power(n, 5) + * ( + 2.3233586127079147e8 + - 1.3185401467528436e8 * S1 + - 1.5658696749069476e8 * S2 + ) + + np.power(n, 2) + * ( + 1.0735720397100002e8 + - 1.0481893979951563e8 * S1 + - 1.2448069904596138e8 * S2 + ) + + np.power(n, 6) + * ( + 1.3733480754676133e8 + - 7.21556540222501e7 * S1 + - 8.569048942860737e7 * S2 + ) + + n + * ( + 2.346811804325443e7 + - 3.948206709361244e7 * S1 + - 4.688804638734895e7 * S2 + ) + + np.power(n, 7) + * ( + 5.9068956110853195e7 + - 2.9326900334110886e7 * S1 + - 3.4827990641994946e7 * S2 + ) + + np.power(n, 8) + * ( + 1.8716920175328404e7 + - 8.904006082429819e6 * S1 + - 1.0574204466962924e7 * S2 + ) + + np.power(n, 9) + * ( + 4.369502175593268e6 + - 2.0112998054058799e6 * S1 + - 2.3885760173381087e6 * S2 + ) + + np.power(n, 10) + * (742367.1089287619 - 333002.79029907763 * S1 - 395466.8898575944 * S2) + + np.power(n, 11) + * (89238.96159823332 - 39216.66399560401 * S1 - 46572.85942560097 * S2) + + np.power(n, 12) + * (7189.465207901569 - 3107.7721714752024 * S1 - 3690.722813269728 * S2) + + np.power(n, 13) + * ( + 348.04953328095235 + - 148.45017641522256 * S1 + - 176.29620914891743 * S2 + ) + + np.power(n, 14) + * (7.649609990582573 - 3.227177748157012 * S1 - 3.832526285846031 * S2) + - 7.94712650633033e6 * S2 + ) + / ( + np.power(1.0 + n, 2) + * np.power(2.0 + n, 4) + * np.power(3.0 + n, 2) + * np.power(4.0 + n, 2) + * np.power(5.0 + n, 2) + * np.power(6.0 + n, 2) + ) + + ( + -2.0536305397787174e17 * S1 + - 2.2256200168054272e17 * S2 + + np.power(n, 7) + * ( + 7.488098037238662e20 + - 2.946375088218397e20 * S1 + - 3.193131016673674e20 * S2 + - 3.799456323070507e20 * S3 + ) + + np.power(n, 8) + * ( + 7.30264831364528e20 + - 2.71532571821718e20 * S1 + - 2.9427314960274712e20 * S2 + - 3.5015098758232205e20 * S3 + ) + + np.power(n, 6) + * ( + 6.177204922810032e20 + - 2.6157067495896564e20 * S1 + - 2.8347695397084837e20 * S2 + - 3.373047643786608e20 * S3 + ) + + np.power(n, 9) + * ( + 5.8400874656639694e20 + - 2.0769852191609772e20 * S1 + - 2.2509306269236576e20 * S2 + - 2.6783469136093286e20 * S3 + ) + + np.power(n, 5) + * ( + 3.991243537765913e20 + - 1.863520884696265e20 * S1 + - 2.019588870723487e20 * S2 + - 2.4030770002248768e20 * S3 + ) + + np.power(n, 10) + * ( + 3.884280841236816e20 + - 1.3331261847836026e20 * S1 + - 1.4447741520738879e20 * S2 + - 1.719114016569323e20 * S3 + ) + + np.power(n, 4) + * ( + 1.941539256202762e20 + - 1.037136201699684e20 * S1 + - 1.1239953077952802e20 * S2 + - 1.3374243202062749e20 * S3 + ) + + np.power(n, 11) + * ( + 2.1714818176898564e20 + - 7.240795785261171e19 * S1 + - 7.84720509610949e19 * S2 + - 9.337265794969823e19 * S3 + ) + + np.power(n, 3) + * ( + 6.674068902186431e19 + - 4.334180202679847e19 * S1 + - 4.697163403386798e19 * S2 + - 5.589080780056582e19 * S3 + ) + + np.power(n, 12) + * ( + 1.0285760474577702e20 + - 3.3495073506999865e19 * S1 + - 3.630025197696012e19 * S2 + - 4.319309830468156e19 * S3 + ) + + np.power(n, 13) + * ( + 4.152987402406034e19 + - 1.3260813853758188e19 * S1 + - 1.437139357853292e19 * S2 + - 1.7100294951308622e19 * S3 + ) + + np.power(n, 2) + * ( + 1.4426634312692584e19 + - 1.2766361168145222e19 * S1 + - 1.383553098146518e19 * S2 + - 1.646268048384875e19 * S3 + ) + + np.power(n, 14) + * ( + 1.4355806022040816e19 + - 4.5090539738436506e18 * S1 + - 4.886682675708466e18 * S2 + - 5.814586778340482e18 * S3 + ) + + n + * ( + 1.4722170431513467e18 + - 2.3589858426577193e18 * S1 + - 2.556548516923281e18 * S2 + - 3.0419968291746964e18 * S3 + ) + + np.power(n, 15) + * ( + 4.2611489273254656e18 + - 1.3198929523220705e18 * S1 + - 1.4304326498012352e18 * S2 + - 1.7020492888122632e18 * S3 + ) + + np.power(n, 16) + * ( + 1.0879213298582682e18 + - 3.330098647641433e17 * S1 + - 3.608991035420647e17 * S2 + - 4.294281611945237e17 * S3 + ) + + np.power(n, 17) + * ( + 2.3903221211390477e17 + - 7.242566351952211e16 * S1 + - 7.849123945967018e16 * S2 + - 9.339549004204315e16 * S3 + ) + + np.power(n, 18) + * ( + 4.516433468485152e16 + - 1.3564628989469896e16 * S1 + - 1.4700652924043664e16 * S2 + - 1.7492075462568086e16 * S3 + ) + + np.power(n, 19) + * ( + 7.324075821658249e15 + - 2.1829261559919405e15 * S1 + - 2.3657440098778855e15 * S2 + - 2.814961550328176e15 * S3 + ) + + np.power(n, 20) + * ( + 1.0158957617673035e15 + - 3.007636290956304e14 * S1 + - 3.25952278307278e14 * S2 + - 3.878454840615735e14 * S3 + ) + + np.power(n, 21) + * ( + 1.1991809347780238e14 + - 3.529401882158612e13 * S1 + - 3.8249857139003e13 * S2 + - 4.551290279179315e13 * S3 + ) + + np.power(n, 22) + * ( + 1.1961219447874947e13 + - 3.5021031665673315e12 * S1 + - 3.795400758536529e12 * S2 + - 4.516087606586902e12 * S3 + ) + + np.power(n, 23) + * ( + 9.983887045155367e11 + - 2.909667375174094e11 * S1 + - 3.153349069853116e11 * S2 + - 3.752120410888339e11 * S3 + ) + + np.power(n, 24) + * ( + 6.881721914457945e10 + - 1.9973221161205063e10 * S1 + - 2.164595819715926e10 * S2 + - 2.575618485795491e10 * S3 + ) + + np.power(n, 25) + * ( + 3.8459999519303937e9 + - 1.1121280148924243e9 * S1 + - 1.2052676093633516e9 * S2 + - 1.4341289522651784e9 * S3 + ) + + np.power(n, 26) + * ( + 1.6979480143673667e8 + - 4.893579744396906e7 * S1 + - 5.303412089955037e7 * S2 + - 6.310446547232142e7 * S3 + ) + + np.power(n, 27) + * ( + 5.6960113322322285e6 + - 1.6367080201903752e6 * S1 + - 1.7737806586155398e6 * S2 + - 2.110593678720238e6 * S3 + ) + + np.power(n, 28) + * ( + 136369.8397219097 + - 39078.72687348644 * S1 + - 42351.53065569196 * S2 + - 50393.41953125001 * S3 + ) + + np.power(n, 29) + * ( + 2074.721945948902 + - 593.0786658463794 * S1 + - 642.7484032206632 * S2 + - 764.7962053571429 * S3 + ) + + np.power(n, 30) + * ( + 15.06796770343253 + - 4.297671491640431 * S1 + - 4.657597124787415 * S2 + - 5.542001488095237 * S3 + ) + - 2.648230217127936e17 * S3 + ) + / ( + np.power(1.0 + n, 6) + * np.power(2.0 + n, 3) + * np.power(3.0 + n, 3) + * np.power(4.0 + n, 3) + * np.power(5.0 + n, 3) + * np.power(6.0 + n, 3) + * np.power(7.0 + n, 3) + * np.power(8.0 + n, 3) + * np.power(9.0 + n, 3) + ) + - 1.2020569031595942 * mp.betainc(2.0, 1.0 + n, 0.0) + ) + ) diff --git a/src/eko/matching_conditions/n3lo/s_functions.py b/src/eko/matching_conditions/n3lo/s_functions.py index 1bcb2594f..33e6d1970 100644 --- a/src/eko/matching_conditions/n3lo/s_functions.py +++ b/src/eko/matching_conditions/n3lo/s_functions.py @@ -5,6 +5,7 @@ """ import numpy as np import numba as nb +from scipy import special as sp from eko.anomalous_dimensions import harmonics from . import g_functions as gf @@ -18,6 +19,11 @@ li4half = 0.517479 log2 = np.log(2) +# @nb.njit("c16(c16,c16)", cache=True) +def binomial(x,y): + """Binomial coefficient for complex numbers""" + return sp.gamma(x+1)/(sp.gamma(y+1) * sp.gamma(x-y+1)) + @nb.njit("c16(c16)", cache=True) def harmonic_Sm1(N): @@ -162,7 +168,7 @@ def harmonic_S221(N, S1, S2, S21): @nb.njit("c16(c16,c16,c16,c16,c16)", cache=True) def harmonic_Sm221(N, S1, Sm1, S21, Sm21): return ( - (-1) ** (N + 1) * (f.F14F12(N,S1,S21)) + (-1) ** (N + 1) * (f.F14F12(N, S1, S21)) + zeta2 * Sm21 - 3 / 10 * zeta2 ** 2 * Sm1 - 0.119102 diff --git a/tests/test_cs_functions.py b/tests/test_cs_functions.py index 143716549..e7aef0ec8 100644 --- a/tests/test_cs_functions.py +++ b/tests/test_cs_functions.py @@ -206,24 +206,24 @@ def test_S1111l21051(): # np.testing.assert_allclose(test, vals), rtol=15e-03) -def test_S112l2051(): - for N, vals in zip(testN, refvals["S112l2051"]): - S1 = harmonics.harmonic_S1(N) - test = csf.S112l2051(N, S1) - np.testing.assert_allclose(test, vals, rtol=5e-03) +# def test_S112l2051(): +# for N, vals in zip(testN, refvals["S112l2051"]): +# S1 = harmonics.harmonic_S1(N) +# test = csf.S112l2051(N, S1) +# np.testing.assert_allclose(test, vals, rtol=5e-03) -def test_S112l2105(): - for N, vals in zip(testN, refvals["S112l2105"]): - S1 = harmonics.harmonic_S1(N) - S2 = harmonics.harmonic_S2(N) - H21 = hf.H21(N, S1) - H23 = hf.H23(N, S1) - test = csf.S112l2105(N, S1, S2, H21, H23) - rtol = 6e-03 - if N == 100 + 5j: - rtol = 2e-01 - np.testing.assert_allclose(test, vals, rtol=rtol) +# def test_S112l2105(): +# for N, vals in zip(testN, refvals["S112l2105"]): +# S1 = harmonics.harmonic_S1(N) +# S2 = harmonics.harmonic_S2(N) +# H21 = hf.H21(N, S1) +# H23 = hf.H23(N, S1) +# test = csf.S112l2105(N, S1, S2, H21, H23) +# rtol = 6e-03 +# if N == 100 + 5j: +# rtol = 2e-01 +# np.testing.assert_allclose(test, vals, rtol=rtol) def test_S121l2051(): @@ -243,13 +243,13 @@ def test_S121l2051(): # np.testing.assert_allclose(test, vals), rtol=2e-05) -def test_S13l205(): - for N, vals in zip(testN, refvals["S13l205"]): - S1 = harmonics.harmonic_S1(N) - S2 = harmonics.harmonic_S2(N) - S3 = harmonics.harmonic_S3(N) - test = csf.S13l205(N, S1, S2, S3) - np.testing.assert_allclose(test, vals, rtol=3e-03) +# def test_S13l205(): +# for N, vals in zip(testN, refvals["S13l205"]): +# S1 = harmonics.harmonic_S1(N) +# S2 = harmonics.harmonic_S2(N) +# S3 = harmonics.harmonic_S3(N) +# test = csf.S13l205(N, S1, S2, S3) +# np.testing.assert_allclose(test, vals, rtol=3e-03) # not given alone @@ -309,3 +309,26 @@ def test_S211l2051_S211l2105_S22l205(): if N == 5j + 100: rtol = 25e-01 np.testing.assert_allclose(test, vals, rtol=rtol) + +def test_S1111l21105_S112l2051_S112l2105_S121l2105_S13l205(): + for N, vals in zip( + testN, + np.array(refvals["S1111l21105"]) + + np.array(refvals["S112l2051"]) + - np.array(refvals["S112l2105"]) + + np.array(refvals["S121l2105"]) + - np.array(refvals["S13l205"]), + ): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + S3 = harmonics.harmonic_S3(N) + H21 = hf.H21(N,S1) + H22 = hf.H22() + H23 = hf.H23(N,S1) + H24 = hf.H24() + H25 = hf.H25() + test = hf.H27(N, S1, S2, S3, H21, H22, H23,H24,H25) + rtol = 2e-03 + if N == 5j + 100: + rtol = 2e-01 + np.testing.assert_allclose(test, vals, rtol=rtol) From 780f872f54cbeee598df4f04debea89a2b8120ea Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Wed, 29 Sep 2021 15:08:03 +0200 Subject: [PATCH 36/71] Adding N3LO gluon OME --- src/eko/matching_conditions/n3lo/aHg.py | 2120 +++++++++++++++++- src/eko/matching_conditions/n3lo/aHgstfac.py | 930 +++++++- src/eko/matching_conditions/n3lo/agg.py | 748 +++++- src/eko/matching_conditions/n3lo/aggTF2.py | 301 +++ src/eko/matching_conditions/n3lo/agq.py | 615 ++++- 5 files changed, 4651 insertions(+), 63 deletions(-) create mode 100644 src/eko/matching_conditions/n3lo/aggTF2.py diff --git a/src/eko/matching_conditions/n3lo/aHg.py b/src/eko/matching_conditions/n3lo/aHg.py index 889f6cbfa..167f75a7e 100644 --- a/src/eko/matching_conditions/n3lo/aHg.py +++ b/src/eko/matching_conditions/n3lo/aHg.py @@ -1,21 +1,2111 @@ # -*- coding: utf-8 -*- -"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +"""This module contains the |OME| aHg, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np -from ...anomalous_dimensions import harmonics -from . import g_functions as gf +from .aHgstfac import A_Hgstfac_3 -zeta2 = harmonics.zeta2 -zeta3 = harmonics.zeta3 -zeta4 = harmonics.zeta4 -zeta5 = harmonics.zeta5 -li4half = 0.517479 -li5half = 0.508401 - -@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) -def A_Qg_3(n, sx, spx, nf, L): - S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] - Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] - return 0.0 +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) +def A_Hg_3(n, sx, smx, s3x, s4x, nf): + S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] + Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] + S21, Sm21 = s3x[0], s3x[2] + S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] + return ( + A_Hgstfac_3(n, sx, smx, s3x, s4x, nf) + + (1.0684950250307503 * (2.0 + n + np.power(n, 2))) + / (n * (1.0 + n) * (2.0 + n)) + + 0.3333333333333333 + * nf + * ( + ( + -1.0684950250307503 + * (2.0 + n + np.power(n, 2)) + * ( + -24.0 + - 28.0 * n + - 38.0 * np.power(n, 2) + - 17.0 * np.power(n, 3) + - 1.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 0.3655409037440503 + * ( + -1728.0 + - 5664.0 * n + - 9200.0 * np.power(n, 2) + - 15680.0 * np.power(n, 3) + - 20036.0 * np.power(n, 4) + - 17554.0 * np.power(n, 5) + - 6701.0 * np.power(n, 6) + + 5081.0 * np.power(n, 7) + + 9270.0 * np.power(n, 8) + + 6556.0 * np.power(n, 9) + + 2331.0 * np.power(n, 10) + + 333.0 * np.power(n, 11) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 1.3333333333333333 + * ( + -768.0 + - 5248.0 * n + - 16064.0 * np.power(n, 2) + - 28256.0 * np.power(n, 3) + - 30384.0 * np.power(n, 4) + - 30808.0 * np.power(n, 5) + - 35844.0 * np.power(n, 6) + - 39994.0 * np.power(n, 7) + - 40778.0 * np.power(n, 8) + - 30218.0 * np.power(n, 9) + - 2639.0 * np.power(n, 10) + + 29583.0 * np.power(n, 11) + + 45159.0 * np.power(n, 12) + + 37119.0 * np.power(n, 13) + + 19019.0 * np.power(n, 14) + + 6055.0 * np.power(n, 15) + + 1099.0 * np.power(n, 16) + + 87.0 * np.power(n, 17) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 6) + * np.power(1.0 + n, 6) + * np.power(2.0 + n, 5) + ) + - ( + 2.9243272299524024 + * (12.0 + 28.0 * n + 11.0 * np.power(n, 2) + 5.0 * np.power(n, 3)) + * S1 + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + + ( + 5.333333333333333 + * ( + -12.0 + - 44.0 * n + - 19.0 * np.power(n, 2) + - 11.0 * np.power(n, 3) + - 2.0 * np.power(n, 4) + + 2.0 * np.power(n, 5) + ) + * S1 + ) + / (np.power(n, 2) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 2.6666666666666665 + * ( + -4.0 + - 18.0 * n + - 32.0 * np.power(n, 2) + - 5.0 * np.power(n, 3) + + np.power(n, 4) + ) + * np.power(S1, 2) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 2.6666666666666665 + * ( + -192.0 + - 736.0 * n + - 1232.0 * np.power(n, 2) + - 1688.0 * np.power(n, 3) + - 1424.0 * np.power(n, 4) + - 1152.0 * np.power(n, 5) + - 1060.0 * np.power(n, 6) + - 459.0 * np.power(n, 7) + + 74.0 * np.power(n, 8) + + 144.0 * np.power(n, 9) + + 42.0 * np.power(n, 10) + + 3.0 * np.power(n, 11) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + (2.0 + 3.0 * n) + * (-1.7777777777777777 * np.power(S1, 3) - 5.333333333333333 * S1 * S2) + ) + / (np.power(n, 2) * (2.0 + n)) + + (21.333333333333332 * (-2.0 - 3.0 * n + np.power(n, 2)) * S21) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - ( + 1.7777777777777777 + * ( + -144.0 + - 200.0 * n + - 272.0 * np.power(n, 2) + - 314.0 * np.power(n, 3) + - 353.0 * np.power(n, 4) + - 44.0 * np.power(n, 5) + + 118.0 * np.power(n, 6) + + 54.0 * np.power(n, 7) + + 3.0 * np.power(n, 8) + ) + * S3 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -1.0684950250307503 * S1 + - 2.193245422464302 * np.power(S1, 2) + - 0.1111111111111111 * np.power(S1, 4) + - 0.6666666666666666 * np.power(S1, 2) * S2 + - 0.3333333333333333 * np.power(S2, 2) + + 10.666666666666666 * S211 + + S1 * (-5.333333333333333 * S21 - 0.8888888888888888 * S3) + - 5.333333333333333 * S31 + + 2.0 * S4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 0.3333333333333333 + * ( + ( + -2.1369900500615007 + * (2.0 + n + np.power(n, 2)) + * ( + -12.0 + - 20.0 * n + - 31.0 * np.power(n, 2) + - 16.0 * np.power(n, 3) + + 7.0 * np.power(n, 4) + + 18.0 * np.power(n, 5) + + 6.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 0.3655409037440503 + * ( + -1728.0 + - 4992.0 * n + - 8944.0 * np.power(n, 2) + - 16288.0 * np.power(n, 3) + - 20572.0 * np.power(n, 4) + - 14684.0 * np.power(n, 5) + + 1193.0 * np.power(n, 6) + + 11479.0 * np.power(n, 7) + + 10350.0 * np.power(n, 8) + + 5378.0 * np.power(n, 9) + + 1701.0 * np.power(n, 10) + + 243.0 * np.power(n, 11) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 0.6666666666666666 + * ( + 192.0 + + 736.0 * n + + 1616.0 * np.power(n, 2) + + 1544.0 * np.power(n, 3) + + 256.0 * np.power(n, 4) + + 1676.0 * np.power(n, 5) + + 3876.0 * np.power(n, 6) + + 905.0 * np.power(n, 7) + - 3313.0 * np.power(n, 8) + - 1207.0 * np.power(n, 9) + + 5375.0 * np.power(n, 10) + + 9235.0 * np.power(n, 11) + + 6877.0 * np.power(n, 12) + + 2567.0 * np.power(n, 13) + + 385.0 * np.power(n, 14) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 6) + * np.power(1.0 + n, 6) + * np.power(2.0 + n, 2) + ) + - ( + 14.621636149762011 + * (6.0 + 11.0 * n + 4.0 * np.power(n, 2) + np.power(n, 3)) + * S1 + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + + ( + 10.666666666666666 + * ( + -12.0 + - 44.0 * n + - 19.0 * np.power(n, 2) + - 11.0 * np.power(n, 3) + - 2.0 * np.power(n, 4) + + 2.0 * np.power(n, 5) + ) + * S1 + ) + / (np.power(n, 2) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 5.333333333333333 + * ( + -4.0 + - 18.0 * n + - 32.0 * np.power(n, 2) + - 5.0 * np.power(n, 3) + + np.power(n, 4) + ) + * np.power(S1, 2) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 5.333333333333333 + * ( + -8.0 + - 20.0 * n + - 56.0 * np.power(n, 2) + - 64.0 * np.power(n, 3) + + 15.0 * np.power(n, 4) + + 30.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + ) + * S2 + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + (2.0 + 3.0 * n) + * (-3.5555555555555554 * np.power(S1, 3) - 10.666666666666666 * S1 * S2) + ) + / (np.power(n, 2) * (2.0 + n)) + + (42.666666666666664 * (-2.0 - 3.0 * n + np.power(n, 2)) * S21) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - ( + 3.5555555555555554 + * ( + -8.0 + - 22.0 * n + + 43.0 * np.power(n, 2) + + 48.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + * S3 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -4.273980100123001 * S1 + - 0.2222222222222222 * np.power(S1, 4) + - 1.3333333333333333 * np.power(S1, 2) * S2 + - 0.6666666666666666 * np.power(S2, 2) + + 1.6449340668482262 + * (-3.3333333333333335 * np.power(S1, 2) + 2.0 * S2) + + 21.333333333333332 * S211 + + S1 * (-10.666666666666666 * S21 - 1.7777777777777777 * S3) + - 10.666666666666666 * S31 + + 4.0 * S4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 0.8888888888888888 + * ( + (-437.8296616868554 * (2.0 + n + np.power(n, 2))) + / (n * (1.0 + n) * (2.0 + n)) + + ( + 0.8013712687730628 + * (2.0 + n + np.power(n, 2)) + * ( + 4.0 + + 12.0 * n + + 165.0 * np.power(n, 2) + + 306.0 * np.power(n, 3) + + 153.0 * np.power(n, 4) + ) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 0.8224670334241131 + * ( + -48.0 + - 184.0 * n + - 176.0 * np.power(n, 2) + + 1182.0 * np.power(n, 3) + + 4307.0 * np.power(n, 4) + + 6174.0 * np.power(n, 5) + + 5036.0 * np.power(n, 6) + + 2532.0 * np.power(n, 7) + + 633.0 * np.power(n, 8) + ) + ) + / (np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + - ( + 1.0 + * ( + 16.0 + + 120.0 * n + + 444.0 * np.power(n, 2) + + 1066.0 * np.power(n, 3) + + 1540.0 * np.power(n, 4) + + 246.0 * np.power(n, 5) + - 4163.0 * np.power(n, 6) + - 8462.0 * np.power(n, 7) + - 7605.0 * np.power(n, 8) + - 3148.0 * np.power(n, 9) + - 311.0 * np.power(n, 10) + + 138.0 * np.power(n, 11) + + 23.0 * np.power(n, 12) + ) + ) + / (np.power(n, 6) * np.power(1.0 + n, 6) * (2.0 + n)) + - ( + 13.15947253478581 + * ( + -10.0 + - 29.0 * n + - 21.0 * np.power(n, 2) + + 8.0 * np.power(n, 3) + + 39.0 * np.power(n, 4) + + 36.0 * np.power(n, 5) + + 13.0 * np.power(n, 6) + ) + * S1 + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 4.0 + * ( + -8.0 + - 48.0 * n + - 114.0 * np.power(n, 2) + - 90.0 * np.power(n, 3) + + 240.0 * np.power(n, 4) + + 889.0 * np.power(n, 5) + + 1405.0 * np.power(n, 6) + + 1119.0 * np.power(n, 7) + + 407.0 * np.power(n, 8) + + 62.0 * np.power(n, 9) + + 10.0 * np.power(n, 10) + ) + * S1 + ) + / (np.power(n, 5) * np.power(1.0 + n, 5) * (2.0 + n)) + - ( + 6.579736267392905 + * ( + 20.0 + + 48.0 * n + + 43.0 * np.power(n, 2) + + 14.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + * np.power(S1, 2) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 2.0 + * ( + -8.0 + - 96.0 * n + - 202.0 * np.power(n, 2) + + 208.0 * np.power(n, 3) + + 227.0 * np.power(n, 4) + + 140.0 * np.power(n, 5) + + 51.0 * np.power(n, 6) + ) + * np.power(S1, 2) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 1.3333333333333333 + * ( + -4.0 + - 40.0 * n + - 111.0 * np.power(n, 2) + - 180.0 * np.power(n, 3) + - 15.0 * np.power(n, 4) + + 18.0 * np.power(n, 5) + ) + * np.power(S1, 3) + ) + / (np.power(n, 3) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 0.3333333333333333 + * ( + 36.0 + + 120.0 * n + + 139.0 * np.power(n, 2) + + 54.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + * np.power(S1, 4) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 2.0 + * ( + -16.0 + - 64.0 * n + - 244.0 * np.power(n, 2) + - 636.0 * np.power(n, 3) + - 434.0 * np.power(n, 4) + + 697.0 * np.power(n, 5) + + 1133.0 * np.power(n, 6) + + 427.0 * np.power(n, 7) + + np.power(n, 8) + ) + * S2 + ) + / (np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + - ( + 4.0 + * ( + -20.0 + - 60.0 * n + - 131.0 * np.power(n, 2) + - 119.0 * np.power(n, 3) + + 57.0 * np.power(n, 4) + + 87.0 * np.power(n, 5) + + 18.0 * np.power(n, 6) + ) + * S1 + * S2 + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 2.0 + * (10.0 + 27.0 * n + 24.0 * np.power(n, 2) + 3.0 * np.power(n, 3)) + * np.power(S1, 2) + * S2 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + - ( + 16.0 + * (-2.0 - 3.0 * n + np.power(n, 2)) + * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + * S21 + ) + / (np.power(n, 3) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 16.0 + * ( + 12.0 + + 28.0 * n + + 19.0 * np.power(n, 2) + + 2.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + * S1 + * S21 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 1.3333333333333333 + * ( + -16.0 + - 68.0 * n + + 92.0 * np.power(n, 2) + + 399.0 * np.power(n, 3) + + 519.0 * np.power(n, 4) + + 297.0 * np.power(n, 5) + + 57.0 * np.power(n, 6) + ) + * S3 + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 2.6666666666666665 + * ( + -12.0 + - 36.0 * n + + 97.0 * np.power(n, 2) + + 102.0 * np.power(n, 3) + + 9.0 * np.power(n, 4) + ) + * S1 + * S3 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + (2.0 + n + np.power(n, 2)) + * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + * ( + -6.410970150184502 * S1 + + 13.15947253478581 * S2 + - 1.0 * np.power(S2, 2) + + 32.0 * S211 + - 16.0 * S31 + + 6.0 * S4 + ) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + (26.31894506957162 * (2.0 + n + np.power(n, 2)) * Sm2) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -3.205485075092251 * np.power(S1, 2) + - 0.3333333333333333 * np.power(S1, 5) + - 2.0 * np.power(S1, 3) * S2 + + np.power(S1, 2) * (-16.0 * S21 - 2.6666666666666665 * S3) + + S1 + * (-1.0 * np.power(S2, 2) + 32.0 * S211 - 16.0 * S31 + 6.0 * S4) + + 1.6449340668482262 + * ( + -4.0 * np.power(S1, 3) + + 8.0 * S1 * S2 + + 4.0 * S3 + + 8.0 * S1 * Sm2 + - 8.0 * Sm21 + + 4.0 * Sm3 + ) + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 0.75 + * nf + * ( + ( + 2.1369900500615007 + * ( + 8.0 + + 12.0 * n + + 52.0 * np.power(n, 2) + - 19.0 * np.power(n, 3) + - 14.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + 0.7310818074881006 + * ( + 48.0 + + 88.0 * n + - 68.0 * np.power(n, 2) + + 152.0 * np.power(n, 3) + - 357.0 * np.power(n, 4) + - 252.0 * np.power(n, 5) + + 50.0 * np.power(n, 6) + + 36.0 * np.power(n, 7) + + 15.0 * np.power(n, 8) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 5.333333333333333 + * ( + 64.0 + + 448.0 * n + + 1392.0 * np.power(n, 2) + + 2400.0 * np.power(n, 3) + + 2268.0 * np.power(n, 4) + + 1500.0 * np.power(n, 5) + + 457.0 * np.power(n, 6) + - 1116.0 * np.power(n, 7) + - 1858.0 * np.power(n, 8) + - 826.0 * np.power(n, 9) + + 682.0 * np.power(n, 10) + + 1183.0 * np.power(n, 11) + + 765.0 * np.power(n, 12) + + 267.0 * np.power(n, 13) + + 50.0 * np.power(n, 14) + + 4.0 * np.power(n, 15) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 5) + ) + + ( + 2.9243272299524024 + * ( + 20.0 + + 28.0 * n + + 47.0 * np.power(n, 2) + + 32.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * S1 + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - ( + 5.333333333333333 + * ( + 32.0 + + 72.0 * n + + 396.0 * np.power(n, 2) + + 810.0 * np.power(n, 3) + + 759.0 * np.power(n, 4) + + 386.0 * np.power(n, 5) + + 117.0 * np.power(n, 6) + + 22.0 * np.power(n, 7) + + 2.0 * np.power(n, 8) + ) + * S1 + ) + / (n * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + + ( + 2.6666666666666665 + * ( + -8.0 + + 16.0 * n + + 18.0 * np.power(n, 2) + + 4.0 * np.power(n, 3) + + 7.0 * np.power(n, 4) + + 6.0 * np.power(n, 5) + + np.power(n, 6) + ) + * np.power(S1, 2) + ) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + ( + 1.7777777777777777 + * (2.0 + 11.0 * n + 8.0 * np.power(n, 2) + np.power(n, 3)) + * np.power(S1, 3) + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + 2.6666666666666665 + * ( + 64.0 + + 256.0 * n + + 456.0 * np.power(n, 2) + + 600.0 * np.power(n, 3) + + 290.0 * np.power(n, 4) + + 42.0 * np.power(n, 5) + + 105.0 * np.power(n, 6) + + 85.0 * np.power(n, 7) + + 21.0 * np.power(n, 8) + + np.power(n, 9) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 5.333333333333333 + * (-2.0 - 27.0 * n - 12.0 * np.power(n, 2) + 3.0 * np.power(n, 3)) + * S1 + * S2 + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + 14.222222222222221 + * ( + 6.0 + + 7.0 * n + + 3.0 * np.power(n, 2) + + 9.0 * np.power(n, 3) + + 10.0 * np.power(n, 4) + + np.power(n, 5) + ) + * S3 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + ( + 20.0 + + 22.0 * n + + 7.0 * np.power(n, 2) + + 2.0 * np.power(n, 3) + + np.power(n, 4) + ) + * (17.545963379714415 + 21.333333333333332 * Sm2) + ) + / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + ( + (-4.0 - 1.0 * n + np.power(n, 2)) + * ( + -19.232910450553508 + - 35.09192675942883 * S1 + - 42.666666666666664 * S1 * Sm2 + + 42.666666666666664 * Sm21 + - 21.333333333333332 * Sm3 + ) + ) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + 1.0684950250307503 * S1 + + 0.1111111111111111 * np.power(S1, 4) + + 3.3333333333333335 * np.power(S1, 2) * S2 + + 0.3333333333333333 * np.power(S2, 2) + - 2.6666666666666665 * S211 + - 2.6666666666666665 * S31 + + 6.0 * S4 + + (5.333333333333333 * np.power(S1, 2) + 5.333333333333333 * S2) + * Sm2 + + 1.6449340668482262 + * ( + 1.3333333333333333 * np.power(S1, 2) + + 1.3333333333333333 * S2 + + 2.6666666666666665 * Sm2 + ) + + S1 * (8.88888888888889 * S3 - 10.666666666666666 * Sm21) + + 10.666666666666666 * Sm211 + - 5.333333333333333 * Sm22 + + 5.333333333333333 * S1 * Sm3 + - 5.333333333333333 * Sm31 + + 2.6666666666666665 * Sm4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 0.75 + * ( + ( + 4.273980100123001 + * ( + 28.0 + + 42.0 * n + + 92.0 * np.power(n, 2) + + np.power(n, 3) + - 4.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + 0.7310818074881006 + * ( + 672.0 + + 3008.0 * n + + 5352.0 * np.power(n, 2) + + 7460.0 * np.power(n, 3) + + 5276.0 * np.power(n, 4) + + 2451.0 * np.power(n, 5) + + 1894.0 * np.power(n, 6) + + 1100.0 * np.power(n, 7) + + 366.0 * np.power(n, 8) + + 69.0 * np.power(n, 9) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + + ( + 0.09876543209876543 + * ( + 10368.0 + + 59904.0 * n + + 165984.0 * np.power(n, 2) + + 328672.0 * np.power(n, 3) + + 592440.0 * np.power(n, 4) + + 1.113248e6 * np.power(n, 5) + + 1.704634e6 * np.power(n, 6) + + 1.889534e6 * np.power(n, 7) + + 1.57506e6 * np.power(n, 8) + + 1.065977e6 * np.power(n, 9) + + 620328.0 * np.power(n, 10) + + 307057.0 * np.power(n, 11) + + 119006.0 * np.power(n, 12) + + 32317.0 * np.power(n, 13) + + 5436.0 * np.power(n, 14) + + 435.0 * np.power(n, 15) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 5) + ) + - ( + 5.848654459904805 + * ( + 20.0 + + 43.0 * n + + 17.0 * np.power(n, 2) + + 8.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * S1 + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - ( + 0.19753086419753085 + * ( + 864.0 + - 1936.0 * n + - 11056.0 * np.power(n, 2) + - 33648.0 * np.power(n, 3) + - 28270.0 * np.power(n, 4) + + 17745.0 * np.power(n, 5) + + 46431.0 * np.power(n, 6) + + 36343.0 * np.power(n, 7) + + 15787.0 * np.power(n, 8) + + 3960.0 * np.power(n, 9) + + 436.0 * np.power(n, 10) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 4) + ) + + ( + 2.6666666666666665 + * ( + -24.0 + + 12.0 * n + + 14.0 * np.power(n, 2) + - 7.0 * np.power(n, 3) + + 8.0 * np.power(n, 4) + + 11.0 * np.power(n, 5) + + 2.0 * np.power(n, 6) + ) + * np.power(S1, 2) + ) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + ( + 3.5555555555555554 + * (2.0 + 11.0 * n + 8.0 * np.power(n, 2) + np.power(n, 3)) + * np.power(S1, 3) + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + 2.6666666666666665 + * ( + 128.0 + + 512.0 * n + + 904.0 * np.power(n, 2) + + 1172.0 * np.power(n, 3) + + 554.0 * np.power(n, 4) + + 87.0 * np.power(n, 5) + + 233.0 * np.power(n, 6) + + 193.0 * np.power(n, 7) + + 53.0 * np.power(n, 8) + + 4.0 * np.power(n, 9) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 10.666666666666666 + * (-2.0 - 27.0 * n - 12.0 * np.power(n, 2) + 3.0 * np.power(n, 3)) + * S1 + * S2 + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + 28.444444444444443 + * ( + 6.0 + + 7.0 * n + + 3.0 * np.power(n, 2) + + 9.0 * np.power(n, 3) + + 10.0 * np.power(n, 4) + + np.power(n, 5) + ) + * S3 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + ( + 20.0 + + 22.0 * n + + 7.0 * np.power(n, 2) + + 2.0 * np.power(n, 3) + + np.power(n, 4) + ) + * (35.09192675942883 + 42.666666666666664 * Sm2) + ) + / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + ( + (-4.0 - 1.0 * n + np.power(n, 2)) + * ( + -38.465820901107016 + - 70.18385351885766 * S1 + - 85.33333333333333 * S1 * Sm2 + + 85.33333333333333 * Sm21 + - 42.666666666666664 * Sm3 + ) + ) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + 7.479465175215253 * S1 + + 0.2222222222222222 * np.power(S1, 4) + + 6.666666666666667 * np.power(S1, 2) * S2 + + 0.6666666666666666 * np.power(S2, 2) + - 5.333333333333333 * S211 + - 5.333333333333333 * S31 + + 12.0 * S4 + + (10.666666666666666 * np.power(S1, 2) + 10.666666666666666 * S2) + * Sm2 + + 1.6449340668482262 + * ( + 3.3333333333333335 * np.power(S1, 2) + + 3.3333333333333335 * S2 + + 6.666666666666667 * Sm2 + ) + + S1 * (17.77777777777778 * S3 - 21.333333333333332 * Sm21) + + 21.333333333333332 * Sm211 + - 10.666666666666666 * Sm22 + + 10.666666666666666 * S1 * Sm3 + - 10.666666666666666 * Sm31 + + 5.333333333333333 * Sm4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 4.5 + * ( + ( + -0.5342475125153752 + * ( + -24.0 + - 46.0 * n + - 35.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * ( + 8.0 + + 12.0 * n + + 52.0 * np.power(n, 2) + - 19.0 * np.power(n, 3) + - 14.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 0.3655409037440503 + * ( + -3456.0 + - 17184.0 * n + - 39184.0 * np.power(n, 2) + - 62960.0 * np.power(n, 3) + - 65616.0 * np.power(n, 4) + - 41818.0 * np.power(n, 5) + - 5017.0 * np.power(n, 6) + - 4436.0 * np.power(n, 7) + - 18414.0 * np.power(n, 8) + - 11265.0 * np.power(n, 9) + - 1501.0 * np.power(n, 10) + + 794.0 * np.power(n, 11) + + 420.0 * np.power(n, 12) + + 69.0 * np.power(n, 13) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 4) + ) + - ( + 1.3333333333333333 + * ( + -24.0 + - 46.0 * n + - 35.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * ( + 64.0 + + 448.0 * n + + 1392.0 * np.power(n, 2) + + 2400.0 * np.power(n, 3) + + 2268.0 * np.power(n, 4) + + 1500.0 * np.power(n, 5) + + 457.0 * np.power(n, 6) + - 1116.0 * np.power(n, 7) + - 1858.0 * np.power(n, 8) + - 826.0 * np.power(n, 9) + + 682.0 * np.power(n, 10) + + 1183.0 * np.power(n, 11) + + 765.0 * np.power(n, 12) + + 267.0 * np.power(n, 13) + + 50.0 * np.power(n, 14) + + 4.0 * np.power(n, 15) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 6) + * np.power(1.0 + n, 6) + * np.power(2.0 + n, 6) + ) + - ( + 0.5342475125153752 + * ( + -240.0 + - 668.0 * n + - 356.0 * np.power(n, 2) + - 487.0 * np.power(n, 3) + - 105.0 * np.power(n, 4) + + 339.0 * np.power(n, 5) + + 77.0 * np.power(n, 6) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 0.7310818074881006 + * ( + -864.0 + - 2160.0 * n + - 472.0 * np.power(n, 2) + + 36.0 * np.power(n, 3) + + 4926.0 * np.power(n, 4) + + 3755.0 * np.power(n, 5) + - 1505.0 * np.power(n, 6) + - 334.0 * np.power(n, 7) + + 1124.0 * np.power(n, 8) + + 575.0 * np.power(n, 9) + + 103.0 * np.power(n, 10) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 1.3333333333333333 + * ( + 768.0 + + 5376.0 * n + + 16704.0 * np.power(n, 2) + + 29568.0 * np.power(n, 3) + + 30416.0 * np.power(n, 4) + + 31936.0 * np.power(n, 5) + + 44956.0 * np.power(n, 6) + + 54008.0 * np.power(n, 7) + + 40728.0 * np.power(n, 8) + + 15041.0 * np.power(n, 9) + + 1996.0 * np.power(n, 10) + + 2510.0 * np.power(n, 11) + + 3222.0 * np.power(n, 12) + + 1503.0 * np.power(n, 13) + + 314.0 * np.power(n, 14) + + 26.0 * np.power(n, 15) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 5) + ) + - ( + 2.193245422464302 + * ( + -48.0 + - 116.0 * n + - 92.0 * np.power(n, 2) + - 133.0 * np.power(n, 3) + + 9.0 * np.power(n, 4) + + 81.0 * np.power(n, 5) + + 11.0 * np.power(n, 6) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + 0.6666666666666666 + * ( + -192.0 + - 752.0 * n + - 72.0 * np.power(n, 2) + - 6116.0 * np.power(n, 3) + - 9218.0 * np.power(n, 4) + + 1258.0 * np.power(n, 5) + + 9211.0 * np.power(n, 6) + + 6514.0 * np.power(n, 7) + + 2106.0 * np.power(n, 8) + + 392.0 * np.power(n, 9) + + 37.0 * np.power(n, 10) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 4) + ) + - ( + 0.4444444444444444 + * ( + -48.0 + - 212.0 * n + - 1200.0 * np.power(n, 2) + - 769.0 * np.power(n, 3) + + 190.0 * np.power(n, 4) + + 208.0 * np.power(n, 5) + + 128.0 * np.power(n, 6) + + 101.0 * np.power(n, 7) + + 18.0 * np.power(n, 8) + ) + * np.power(S1, 3) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + + ( + 0.1111111111111111 + * ( + -48.0 + - 20.0 * n + + 292.0 * np.power(n, 2) + - 181.0 * np.power(n, 3) + - 327.0 * np.power(n, 4) + - 15.0 * np.power(n, 5) + + 11.0 * np.power(n, 6) + ) + * np.power(S1, 4) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 0.6666666666666666 + * ( + -24.0 + - 46.0 * n + - 35.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * ( + 64.0 + + 256.0 * n + + 456.0 * np.power(n, 2) + + 600.0 * np.power(n, 3) + + 290.0 * np.power(n, 4) + + 42.0 * np.power(n, 5) + + 105.0 * np.power(n, 6) + + 85.0 * np.power(n, 7) + + 21.0 * np.power(n, 8) + + np.power(n, 9) + ) + * S2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 4) + ) + - ( + 1.3333333333333333 + * ( + 384.0 + + 1488.0 * n + + 1996.0 * np.power(n, 2) + + 2000.0 * np.power(n, 3) + + 359.0 * np.power(n, 4) + + 586.0 * np.power(n, 5) + + 1296.0 * np.power(n, 6) + + 576.0 * np.power(n, 7) + + 93.0 * np.power(n, 8) + + 6.0 * np.power(n, 9) + ) + * S1 + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + + ( + 0.6666666666666666 + * (-2.0 + n) + * ( + 120.0 + + 326.0 * n + + 213.0 * np.power(n, 2) + + 379.0 * np.power(n, 3) + + 347.0 * np.power(n, 4) + + 55.0 * np.power(n, 5) + ) + * np.power(S1, 2) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 3.5555555555555554 + * ( + -24.0 + - 46.0 * n + - 35.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * ( + 6.0 + + 7.0 * n + + 3.0 * np.power(n, 2) + + 9.0 * np.power(n, 3) + + 10.0 * np.power(n, 4) + + np.power(n, 5) + ) + * S3 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + + ( + 1.7777777777777777 + * ( + -384.0 + - 748.0 * n + - 772.0 * np.power(n, 2) + - 401.0 * np.power(n, 3) + - 195.0 * np.power(n, 4) + + 141.0 * np.power(n, 5) + + 55.0 * np.power(n, 6) + ) + * S1 + * S3 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + ( + 20.0 + + 22.0 * n + + 7.0 * np.power(n, 2) + + 2.0 * np.power(n, 3) + + np.power(n, 4) + ) + * ( + -24.0 + - 46.0 * n + - 35.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * (-4.386490844928604 - 5.333333333333333 * Sm2) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + - ( + 52.63789013914324 + * (1.0 + n + np.power(n, 2)) + * (2.0 + n + np.power(n, 2)) + * Sm2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + ( + 96.0 + + 232.0 * n + - 58.0 * np.power(n, 2) + - 131.0 * np.power(n, 3) + + 5.0 * np.power(n, 5) + ) + * (8.772981689857207 * S1 + 10.666666666666666 * S1 * Sm2) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2) * np.power(2.0 + n, 3)) + + ( + ( + -48.0 + - 116.0 * n + - 44.0 * np.power(n, 2) + - 109.0 * np.power(n, 3) + - 39.0 * np.power(n, 4) + + 57.0 * np.power(n, 5) + + 11.0 * np.power(n, 6) + ) + * ( + 4.386490844928604 * np.power(S1, 2) + + 5.333333333333333 * np.power(S1, 2) * Sm2 + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + (-4.0 - 1.0 * n + np.power(n, 2)) + * ( + -24.0 + - 46.0 * n + - 35.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * ( + 4.808227612638377 + - 10.666666666666666 * Sm21 + + 5.333333333333333 * Sm3 + ) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + ( + ( + -48.0 + - 68.0 * n + - 24.0 * np.power(n, 2) + - 49.0 * np.power(n, 3) + + 34.0 * np.power(n, 4) + + 11.0 * np.power(n, 5) + ) + * ( + 4.808227612638377 * S1 + - 10.666666666666666 * S1 * Sm21 + + 5.333333333333333 * S1 * Sm3 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * (1.0 + n) * np.power(2.0 + n, 2)) + + ( + (2.0 + n + np.power(n, 2)) + * ( + -24.0 + - 46.0 * n + - 35.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * ( + 0.3333333333333333 * np.power(S2, 2) + - 2.6666666666666665 * S211 + - 2.6666666666666665 * S31 + + 6.0 * S4 + + 5.333333333333333 * S2 * Sm2 + + 1.6449340668482262 + * (2.6666666666666665 * S2 + 2.6666666666666665 * Sm2) + + 10.666666666666666 * Sm211 + - 5.333333333333333 * Sm22 + - 5.333333333333333 * Sm31 + + 2.6666666666666665 * Sm4 + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -3.205485075092251 * np.power(S1, 2) + - 0.3333333333333333 * np.power(S1, 5) + - 10.0 * np.power(S1, 3) * S2 + + (-16.0 * np.power(S1, 3) - 16.0 * S1 * S2) * Sm2 + + np.power(S1, 2) * (-26.666666666666668 * S3 + 32.0 * Sm21) + + 1.6449340668482262 + * ( + -4.0 * np.power(S1, 3) + + 3.6666666666666665 * S2 + - 8.0 * S1 * S2 + - 2.0 * S3 + - 12.0 * S1 * Sm2 + + 4.0 * Sm21 + - 2.0 * Sm3 + ) + - 16.0 * np.power(S1, 2) * Sm3 + + S1 + * ( + -1.0 * np.power(S2, 2) + + 8.0 * S211 + + 8.0 * S31 + - 18.0 * S4 + - 32.0 * Sm211 + + 16.0 * Sm22 + + 16.0 * Sm31 + ) + - 8.0 * S1 * Sm4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 2.0 + * ( + (218.9148308434277 * (2.0 + n + np.power(n, 2))) + / (n * (1.0 + n) * (2.0 + n)) + - ( + 0.2671237562576876 + * ( + 192.0 + + 664.0 * n + - 404.0 * np.power(n, 2) + - 2554.0 * np.power(n, 3) + - 681.0 * np.power(n, 4) + + 1692.0 * np.power(n, 5) + + 3002.0 * np.power(n, 6) + + 2190.0 * np.power(n, 7) + + 507.0 * np.power(n, 8) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 0.09138522593601257 + * ( + 1776.0 + + 9488.0 * n + + 25144.0 * np.power(n, 2) + + 44064.0 * np.power(n, 3) + + 55339.0 * np.power(n, 4) + + 37623.0 * np.power(n, 5) + + 21430.0 * np.power(n, 6) + + 15070.0 * np.power(n, 7) + + 5751.0 * np.power(n, 8) + + 891.0 * np.power(n, 9) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 2) + ) + + ( + 0.3333333333333333 + * ( + 1408.0 + - 4480.0 * n + - 64672.0 * np.power(n, 2) + - 200160.0 * np.power(n, 3) + - 261272.0 * np.power(n, 4) + - 73752.0 * np.power(n, 5) + + 207634.0 * np.power(n, 6) + + 337718.0 * np.power(n, 7) + + 425270.0 * np.power(n, 8) + + 712841.0 * np.power(n, 9) + + 1.086519e6 * np.power(n, 10) + + 1.160715e6 * np.power(n, 11) + + 831483.0 * np.power(n, 12) + + 394315.0 * np.power(n, 13) + + 119399.0 * np.power(n, 14) + + 20963.0 * np.power(n, 15) + + 1623.0 * np.power(n, 16) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 6) + * np.power(2.0 + n, 5) + ) + - ( + 0.5342475125153752 + * ( + -312.0 + - 556.0 * n + - 1054.0 * np.power(n, 2) + + 259.0 * np.power(n, 3) + + 351.0 * np.power(n, 4) + + 93.0 * np.power(n, 5) + + 67.0 * np.power(n, 6) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + 0.7310818074881006 + * ( + 144.0 + - 48.0 * n + - 1096.0 * np.power(n, 2) + + 184.0 * np.power(n, 3) + - 381.0 * np.power(n, 4) + + 358.0 * np.power(n, 5) + + 924.0 * np.power(n, 6) + + 370.0 * np.power(n, 7) + + 121.0 * np.power(n, 8) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 2.6666666666666665 + * ( + 576.0 + + 4032.0 * n + + 10416.0 * np.power(n, 2) + + 7584.0 * np.power(n, 3) + - 16628.0 * np.power(n, 4) + - 40468.0 * np.power(n, 5) + - 40915.0 * np.power(n, 6) + - 33352.0 * np.power(n, 7) + - 27541.0 * np.power(n, 8) + - 11753.0 * np.power(n, 9) + + 6624.0 * np.power(n, 10) + + 11508.0 * np.power(n, 11) + + 6497.0 * np.power(n, 12) + + 1953.0 * np.power(n, 13) + + 335.0 * np.power(n, 14) + + 28.0 * np.power(n, 15) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 5) + ) + - ( + 4.386490844928604 + * ( + 12.0 + + 20.0 * n + - 97.0 * np.power(n, 2) + - 44.0 * np.power(n, 3) + - 39.0 * np.power(n, 4) + - 6.0 * np.power(n, 5) + + 10.0 * np.power(n, 6) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 1.3333333333333333 + * ( + -192.0 + - 416.0 * n + - 1712.0 * np.power(n, 2) + - 10832.0 * np.power(n, 3) + - 26920.0 * np.power(n, 4) + - 23342.0 * np.power(n, 5) + - 282.0 * np.power(n, 6) + + 12320.0 * np.power(n, 7) + + 9245.0 * np.power(n, 8) + + 3599.0 * np.power(n, 9) + + 853.0 * np.power(n, 10) + + 95.0 * np.power(n, 11) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 4) + ) + + ( + 0.8888888888888888 + * ( + -48.0 + - 128.0 * n + + 84.0 * np.power(n, 2) + + 300.0 * np.power(n, 3) + - 78.0 * np.power(n, 4) + - 1251.0 * np.power(n, 5) + - 1116.0 * np.power(n, 6) + - 115.0 * np.power(n, 7) + + 156.0 * np.power(n, 8) + + 36.0 * np.power(n, 9) + ) + * np.power(S1, 3) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 0.2222222222222222 + * ( + 84.0 + + 296.0 * n + + 329.0 * np.power(n, 2) + - 317.0 * np.power(n, 3) + - 444.0 * np.power(n, 4) + - 93.0 * np.power(n, 5) + + np.power(n, 6) + ) + * np.power(S1, 4) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 6.579736267392905 + * (2.0 + n + np.power(n, 2)) + * ( + 4.0 + + 4.0 * n + + 7.0 * np.power(n, 2) + + 6.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 1.3333333333333333 + * ( + 112.0 + + 992.0 * n + + 2888.0 * np.power(n, 2) + + 5000.0 * np.power(n, 3) + + 8997.0 * np.power(n, 4) + + 13213.0 * np.power(n, 5) + + 12399.0 * np.power(n, 6) + + 7171.0 * np.power(n, 7) + + 2448.0 * np.power(n, 8) + + 456.0 * np.power(n, 9) + + 36.0 * np.power(n, 10) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 2.6666666666666665 + * ( + 240.0 + + 736.0 * n + + 996.0 * np.power(n, 2) + + 588.0 * np.power(n, 3) + - 1116.0 * np.power(n, 4) + - 933.0 * np.power(n, 5) + + 1080.0 * np.power(n, 6) + + 1409.0 * np.power(n, 7) + + 534.0 * np.power(n, 8) + + 66.0 * np.power(n, 9) + ) + * S1 + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + + ( + 1.3333333333333333 + * ( + -84.0 + - 200.0 * n + - 389.0 * np.power(n, 2) + + 359.0 * np.power(n, 3) + + 390.0 * np.power(n, 4) + + 51.0 * np.power(n, 5) + + 17.0 * np.power(n, 6) + ) + * np.power(S1, 2) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 0.6666666666666666 + * (2.0 + n + np.power(n, 2)) + * ( + -6.0 + - 17.0 * n + - 16.0 * np.power(n, 2) + + 2.0 * np.power(n, 3) + + np.power(n, 4) + ) + * np.power(S2, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 5.333333333333333 + * (-2.0 - 3.0 * n + np.power(n, 2)) + * ( + -24.0 + - 46.0 * n + - 35.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * S21 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 5.333333333333333 + * ( + -20.0 + - 176.0 * n + - 145.0 * np.power(n, 2) + - 3.0 * np.power(n, 3) + + 45.0 * np.power(n, 4) + + 11.0 * np.power(n, 5) + ) + * S1 + * S21 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + 2.6666666666666665 + * (2.0 + n + np.power(n, 2)) + * ( + -84.0 + - 172.0 * n + - 137.0 * np.power(n, 2) + + 70.0 * np.power(n, 3) + + 35.0 * np.power(n, 4) + ) + * S211 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + 0.4444444444444444 + * ( + -96.0 + + 128.0 * n + - 1972.0 * np.power(n, 2) + - 5992.0 * np.power(n, 3) + - 6565.0 * np.power(n, 4) + - 1378.0 * np.power(n, 5) + + 2360.0 * np.power(n, 6) + + 1674.0 * np.power(n, 7) + + 321.0 * np.power(n, 8) + ) + * S3 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 0.8888888888888888 + * ( + 192.0 + + 308.0 * n + - 712.0 * np.power(n, 2) + + 229.0 * np.power(n, 3) + + 1311.0 * np.power(n, 4) + + 591.0 * np.power(n, 5) + + 97.0 * np.power(n, 6) + ) + * S1 + * S3 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 2.6666666666666665 + * (2.0 + n + np.power(n, 2)) + * ( + -60.0 + - 104.0 * n + - 73.0 * np.power(n, 2) + + 62.0 * np.power(n, 3) + + 31.0 * np.power(n, 4) + ) + * S31 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -30.0 + - 41.0 * n + - 22.0 * np.power(n, 2) + + 38.0 * np.power(n, 3) + + 19.0 * np.power(n, 4) + ) + * S4 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - (13.15947253478581 * (2.0 + n + np.power(n, 2)) * Sm2) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + ( + -40.0 + - 200.0 * n + - 404.0 * np.power(n, 2) + - 319.0 * np.power(n, 3) + - 65.0 * np.power(n, 4) + + 27.0 * np.power(n, 5) + + 9.0 * np.power(n, 6) + ) + * (13.15947253478581 + 16.0 * Sm2) + ) + / (n * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + ( + ( + 32.0 + + 172.0 * n + + 256.0 * np.power(n, 2) + + 223.0 * np.power(n, 3) + + 136.0 * np.power(n, 4) + + 47.0 * np.power(n, 5) + + 6.0 * np.power(n, 6) + ) + * (26.31894506957162 * S1 + 32.0 * S1 * Sm2) + ) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + ( + ( + 8.0 + + 20.0 * n + + 62.0 * np.power(n, 2) + + 31.0 * np.power(n, 3) + + 4.0 * np.power(n, 4) + + 3.0 * np.power(n, 5) + ) + * (13.15947253478581 * np.power(S1, 2) + 16.0 * np.power(S1, 2) * Sm2) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + ( + 16.0 + + 58.0 * n + + 77.0 * np.power(n, 2) + + 66.0 * np.power(n, 3) + + 33.0 * np.power(n, 4) + + 6.0 * np.power(n, 5) + ) + * (14.424682837915132 - 32.0 * Sm21 + 16.0 * Sm3) + ) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + + ( + ( + 8.0 + + 20.0 * n + + 46.0 * np.power(n, 2) + + 27.0 * np.power(n, 3) + + 8.0 * np.power(n, 4) + + 3.0 * np.power(n, 5) + ) + * (14.424682837915132 * S1 - 32.0 * S1 * Sm21 + 16.0 * S1 * Sm3) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + (2.0 + n + np.power(n, 2)) + * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + * ( + 16.0 * S2 * Sm2 + + 1.6449340668482262 * (8.0 * S2 + 8.0 * Sm2) + + 32.0 * Sm211 + - 16.0 * Sm22 + - 16.0 * Sm31 + + 8.0 * Sm4 + ) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + 6.410970150184502 * np.power(S1, 2) + + 0.6666666666666666 * np.power(S1, 5) + + 12.0 * np.power(S1, 3) * S2 + + (32.0 + 16.0 * np.power(S1, 3) + 16.0 * S1 * S2) * Sm2 + + np.power(S1, 2) + * (16.0 * S21 + 29.333333333333332 * S3 - 32.0 * Sm21) + + 1.6449340668482262 + * ( + 8.0 * np.power(S1, 3) + - 2.0 * S3 + + 4.0 * S1 * Sm2 + + 4.0 * Sm21 + - 2.0 * Sm3 + ) + + 16.0 * np.power(S1, 2) * Sm3 + + S1 + * ( + 2.0 * np.power(S2, 2) + - 40.0 * S211 + + 8.0 * S31 + + 12.0 * S4 + + 32.0 * Sm211 + - 16.0 * Sm22 + - 16.0 * Sm31 + ) + + 8.0 * S1 * Sm4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + ) diff --git a/src/eko/matching_conditions/n3lo/aHgstfac.py b/src/eko/matching_conditions/n3lo/aHgstfac.py index 9c273aaa7..324b785f5 100644 --- a/src/eko/matching_conditions/n3lo/aHgstfac.py +++ b/src/eko/matching_conditions/n3lo/aHgstfac.py @@ -1,21 +1,919 @@ # -*- coding: utf-8 -*- -"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +"""This module contains the |OME| aHgstfac, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np -from ...anomalous_dimensions import harmonics -from . import g_functions as gf -zeta2 = harmonics.zeta2 -zeta3 = harmonics.zeta3 -zeta4 = harmonics.zeta4 -zeta5 = harmonics.zeta5 -li4half = 0.517479 -li5half = 0.508401 - - -@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) -def A_Qgstfac_3(n, sx, spx, nf, L): - S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] - Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] - return 0.0 +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) +def A_Hgstfac_3(n, sx, smx, s3x, s4x, nf): + S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] + Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] + S21, Sm21 = s3x[0], s3x[2] + S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] + return ( + (-1.0684950250307503 * (2.0 + n + np.power(n, 2))) / (n * (1.0 + n) * (2.0 + n)) + + 1.3333333333333333 + * ( + 0.25 + * ( + 1.6449340668482262 + * ( + ( + 0.2222222222222222 + * ( + 1728.0 + + 4992.0 * n + + 8944.0 * np.power(n, 2) + + 11680.0 * np.power(n, 3) + + 4444.0 * np.power(n, 4) + - 4900.0 * np.power(n, 5) + - 6377.0 * np.power(n, 6) + + 617.0 * np.power(n, 7) + + 6930.0 * np.power(n, 8) + + 6142.0 * np.power(n, 9) + + 2331.0 * np.power(n, 10) + + 333.0 * np.power(n, 11) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 8.88888888888889 + * (6.0 + 11.0 * n + 4.0 * np.power(n, 2) + np.power(n, 3)) + * S1 + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + ) + + ( + 1.6449340668482262 + * (2.0 + n + np.power(n, 2)) + * (-13.333333333333334 * np.power(S1, 2) + 8.0 * S2) + ) + / (n * (1.0 + n) * (2.0 + n)) + + nf + * ( + ( + 0.00411522633744856 + * ( + -1.24416e6 + - 7.865856e6 * n + - 2.3256576e7 * np.power(n, 2) + - 4.2534912e7 * np.power(n, 3) + - 5.3947712e7 * np.power(n, 4) + - 5.5711424e7 * np.power(n, 5) + - 4.075048e7 * np.power(n, 6) + - 1.0343664e7 * np.power(n, 7) + + 1.264032e7 * np.power(n, 8) + + 1.1884298e7 * np.power(n, 9) + - 2.970289e6 * np.power(n, 10) + - 1.0465411e7 * np.power(n, 11) + - 5.568833e6 * np.power(n, 12) + + 575913.0 * np.power(n, 13) + + 1.874085e6 * np.power(n, 14) + + 879391.0 * np.power(n, 15) + + 186525.0 * np.power(n, 16) + + 15777.0 * np.power(n, 17) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 6) + * np.power(1.0 + n, 6) + * np.power(2.0 + n, 5) + ) + - ( + 0.3950617283950617 + * ( + 141.0 + + 521.0 * n + + 789.0 * np.power(n, 2) + + 185.0 * np.power(n, 3) + + 10.0 * np.power(n, 4) + ) + * np.power(S1, 2) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 0.3950617283950617 + * ( + 24.0 + + 83.0 * n + + 49.0 * np.power(n, 2) + + 10.0 * np.power(n, 3) + ) + * np.power(S1, 3) + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + + 1.6449340668482262 + * ( + ( + 0.2222222222222222 + * (-2.0 + n) + * ( + 864.0 + + 3264.0 * n + + 6232.0 * np.power(n, 2) + + 9804.0 * np.power(n, 3) + + 10888.0 * np.power(n, 4) + + 9325.0 * np.power(n, 5) + + 6717.0 * np.power(n, 6) + + 3842.0 * np.power(n, 7) + + 1606.0 * np.power(n, 8) + + 405.0 * np.power(n, 9) + + 45.0 * np.power(n, 10) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 1.7777777777777777 + * ( + 12.0 + + 28.0 * n + + 11.0 * np.power(n, 2) + + 5.0 * np.power(n, 3) + ) + * S1 + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + ) + + ( + 0.2962962962962963 + * ( + -5184.0 + - 16992.0 * n + - 27808.0 * np.power(n, 2) + - 39024.0 * np.power(n, 3) + - 31384.0 * np.power(n, 4) + - 19422.0 * np.power(n, 5) + - 13965.0 * np.power(n, 6) + - 6819.0 * np.power(n, 7) + - 398.0 * np.power(n, 8) + + 1416.0 * np.power(n, 9) + + 547.0 * np.power(n, 10) + + 57.0 * np.power(n, 11) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + S1 + * ( + ( + -0.06584362139917696 + * ( + -2670.0 + - 10217.0 * n + - 7454.0 * np.power(n, 2) + - 5165.0 * np.power(n, 3) + - 924.0 * np.power(n, 4) + + 230.0 * np.power(n, 5) + ) + ) + / (np.power(n, 2) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 1.1851851851851851 + * ( + 24.0 + + 83.0 * n + + 49.0 * np.power(n, 2) + + 10.0 * np.power(n, 3) + ) + * S2 + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + ) + - (42.666666666666664 * (-2.0 - 3.0 * n + np.power(n, 2)) * S21) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - ( + 0.19753086419753085 + * ( + 3888.0 + + 5376.0 * n + + 6832.0 * np.power(n, 2) + + 7472.0 * np.power(n, 3) + + 9129.0 * np.power(n, 4) + + 1736.0 * np.power(n, 5) + - 2382.0 * np.power(n, 6) + - 976.0 * np.power(n, 7) + + 29.0 * np.power(n, 8) + ) + * S3 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + -8.772981689857207 * np.power(S1, 2) + - 1.1851851851851851 * np.power(S1, 4) + + 1.2020569031595942 + * ( + ( + -6.222222222222222 + * ( + -24.0 + - 28.0 * n + - 38.0 * np.power(n, 2) + - 17.0 * np.power(n, 3) + - 1.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * (2.0 + n) + ) + + 24.88888888888889 * S1 + ) + - 7.111111111111111 * np.power(S1, 2) * S2 + - 14.222222222222221 * np.power(S2, 2) + + 85.33333333333333 * S211 + + S1 * (-42.666666666666664 * S21 - 9.481481481481481 * S3) + - 42.666666666666664 * S31 + + 28.444444444444443 * S4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + ) + + 1.5 + * ( + ( + -212.26414844076453 + * ( + -16.0 + - 14.0 * np.power(n, 2) + - 25.0 * np.power(n, 3) + - 5.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + 1.6449340668482262 + * ( + ( + 0.05555555555555555 + * ( + 3552.0 + + 17200.0 * n + + 46032.0 * np.power(n, 2) + + 76456.0 * np.power(n, 3) + + 88078.0 * np.power(n, 4) + + 65115.0 * np.power(n, 5) + + 27752.0 * np.power(n, 6) + + 2506.0 * np.power(n, 7) + - 1566.0 * np.power(n, 8) + - 261.0 * np.power(n, 9) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 0.4444444444444444 + * ( + 288.0 + + 48.0 * n + - 3392.0 * np.power(n, 2) + - 5768.0 * np.power(n, 3) + - 3602.0 * np.power(n, 4) + + 1523.0 * np.power(n, 5) + + 5338.0 * np.power(n, 6) + + 4868.0 * np.power(n, 7) + + 2088.0 * np.power(n, 8) + + 337.0 * np.power(n, 9) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + + ( + 2.6666666666666665 + * ( + 36.0 + + 56.0 * n + + 29.0 * np.power(n, 2) + - 137.0 * np.power(n, 3) + - 120.0 * np.power(n, 4) + - 9.0 * np.power(n, 5) + + np.power(n, 6) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + -212.26414844076453 * S1 + + 1.6449340668482262 + * ( + 32.0 * np.power(S1, 3) + - ( + 12.0 + * ( + -4.0 + - 4.0 * n + - 3.0 * np.power(n, 2) + + 2.0 * np.power(n, 3) + + np.power(n, 4) + ) + * S2 + ) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + - 8.0 * S3 + + ( + (-8.0 * (1.0 + 3.0 * n + 3.0 * np.power(n, 2))) + / (n * (1.0 + n)) + + 16.0 * S1 + ) + * Sm2 + + 16.0 * Sm21 + - 8.0 * Sm3 + ) + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + ) + + 4.5 + * ( + ( + 77.92727282720195 + * (-2.0 + n) + * (3.0 + n) + * ( + 4.0 + + 4.0 * n + + 7.0 * np.power(n, 2) + + 6.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + 7.05120034829508 + * ( + -56.0 + - 20.0 * n + - 62.0 * np.power(n, 2) + - 75.0 * np.power(n, 3) + - 15.0 * np.power(n, 4) + + 27.0 * np.power(n, 5) + + 9.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + 1.6449340668482262 + * ( + ( + 0.2222222222222222 + * ( + -3456.0 + - 17184.0 * n + - 39184.0 * np.power(n, 2) + - 57200.0 * np.power(n, 3) + - 54000.0 * np.power(n, 4) + - 36634.0 * np.power(n, 5) + - 19177.0 * np.power(n, 6) + - 16952.0 * np.power(n, 7) + - 17658.0 * np.power(n, 8) + - 8937.0 * np.power(n, 9) + - 997.0 * np.power(n, 10) + + 1190.0 * np.power(n, 11) + + 552.0 * np.power(n, 12) + + 69.0 * np.power(n, 13) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 4) + ) + + ( + 0.4444444444444444 + * ( + -864.0 + - 2160.0 * n + + 680.0 * np.power(n, 2) + + 2820.0 * np.power(n, 3) + + 3078.0 * np.power(n, 4) + - 601.0 * np.power(n, 5) + - 809.0 * np.power(n, 6) + + 1298.0 * np.power(n, 7) + + 1124.0 * np.power(n, 8) + + 515.0 * np.power(n, 9) + + 103.0 * np.power(n, 10) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 1.3333333333333333 + * ( + -48.0 + - 116.0 * n + + 4.0 * np.power(n, 2) + - 85.0 * np.power(n, 3) + - 87.0 * np.power(n, 4) + + 33.0 * np.power(n, 5) + + 11.0 * np.power(n, 6) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + 184.0593470475842 * S1 + + 1.6449340668482262 + * ( + -16.0 * np.power(S1, 3) + - ( + 1.3333333333333333 + * ( + -48.0 + - 70.0 * n + - 59.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * S2 + ) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + - 32.0 * S1 * S2 + - 8.0 * S3 + + ( + ( + -2.6666666666666665 + * ( + -36.0 + - 58.0 * n + - 47.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + ) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + - 48.0 * S1 + ) + * Sm2 + + 16.0 * Sm21 + - 8.0 * Sm3 + ) + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 0.8888888888888888 + * ( + (106.13207422038226 * (-1.0 + n) * (-2.0 + 3.0 * n + 3.0 * np.power(n, 2))) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + + 1.6449340668482262 + * ( + ( + 0.5 + * ( + 48.0 + + 184.0 * n + + 176.0 * np.power(n, 2) + - 222.0 * np.power(n, 3) + - 947.0 * np.power(n, 4) + - 1374.0 * np.power(n, 5) + - 1196.0 * np.power(n, 6) + - 612.0 * np.power(n, 7) + - 153.0 * np.power(n, 8) + ) + ) + / (np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + + ( + 8.0 + * ( + -10.0 + - 29.0 * n + - 21.0 * np.power(n, 2) + + 8.0 * np.power(n, 3) + + 39.0 * np.power(n, 4) + + 36.0 * np.power(n, 5) + + 13.0 * np.power(n, 6) + ) + * S1 + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 4.0 + * ( + 20.0 + + 48.0 * n + + 43.0 * np.power(n, 2) + + 14.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + * np.power(S1, 2) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + ( + 1.6449340668482262 + * (2.0 + n + np.power(n, 2)) + * ( + -16.0 * np.power(S1, 3) + - (8.0 * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) * S2) + / (n * (1.0 + n)) + + 32.0 * S1 * S2 + + 16.0 * S3 + + (-16.0 / (n * (1.0 + n)) + 32.0 * S1) * Sm2 + - 32.0 * Sm21 + + 16.0 * Sm3 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 0.75 + * ( + 1.6449340668482262 + * ( + ( + -0.4444444444444444 + * ( + 672.0 + + 3008.0 * n + + 5352.0 * np.power(n, 2) + + 6500.0 * np.power(n, 3) + + 5180.0 * np.power(n, 4) + + 3171.0 * np.power(n, 5) + + 2134.0 * np.power(n, 6) + + 1148.0 * np.power(n, 7) + + 414.0 * np.power(n, 8) + + 69.0 * np.power(n, 9) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + + ( + 17.77777777777778 + * ( + 4.0 + - 1.0 * n + + np.power(n, 2) + + 4.0 * np.power(n, 3) + + np.power(n, 4) + ) + * S1 + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + ) + + ( + 1.6449340668482262 + * (2.0 + n + np.power(n, 2)) + * ( + 13.333333333333334 * np.power(S1, 2) + + 13.333333333333334 * S2 + + 26.666666666666668 * Sm2 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + + nf + * ( + ( + -0.03292181069958848 + * ( + 3456.0 + + 18432.0 * n + + 33504.0 * np.power(n, 2) + - 22912.0 * np.power(n, 3) + - 281016.0 * np.power(n, 4) + - 465872.0 * np.power(n, 5) + - 806374.0 * np.power(n, 6) + - 1.459136e6 * np.power(n, 7) + - 1.48494e6 * np.power(n, 8) + - 377441.0 * np.power(n, 9) + + 849246.0 * np.power(n, 10) + + 1.139033e6 * np.power(n, 11) + + 692290.0 * np.power(n, 12) + + 237011.0 * np.power(n, 13) + + 44514.0 * np.power(n, 14) + + 3597.0 * np.power(n, 15) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 5) + ) + + ( + 0.09876543209876543 + * ( + 1256.0 + + 3172.0 * n + + 6816.0 * np.power(n, 2) + + 6430.0 * np.power(n, 3) + + 2355.0 * np.power(n, 4) + + 271.0 * np.power(n, 5) + + 22.0 * np.power(n, 6) + ) + * np.power(S1, 2) + ) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - ( + 0.19753086419753085 + * ( + 134.0 + + 439.0 * n + + 344.0 * np.power(n, 2) + + 107.0 * np.power(n, 3) + + 20.0 * np.power(n, 4) + ) + * np.power(S1, 3) + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + 1.6449340668482262 + * ( + ( + -0.4444444444444444 + * ( + 96.0 + + 224.0 * n + - 48.0 * np.power(n, 2) + - 244.0 * np.power(n, 3) + - 610.0 * np.power(n, 4) + - 501.0 * np.power(n, 5) + - 32.0 * np.power(n, 6) + + 146.0 * np.power(n, 7) + + 90.0 * np.power(n, 8) + + 15.0 * np.power(n, 9) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 1.7777777777777777 + * ( + 20.0 + + 76.0 * n + + 59.0 * np.power(n, 2) + + 20.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * S1 + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + ) + + ( + 0.09876543209876543 + * ( + -1728.0 + - 4032.0 * n + - 3128.0 * np.power(n, 2) + - 6644.0 * np.power(n, 3) + + 7720.0 * np.power(n, 4) + + 15770.0 * np.power(n, 5) + + 6901.0 * np.power(n, 6) + + 806.0 * np.power(n, 7) + - 117.0 * np.power(n, 8) + + 4.0 * np.power(n, 9) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + + S1 + * ( + ( + 0.06584362139917696 + * ( + 864.0 + - 2672.0 * n + - 11408.0 * np.power(n, 2) + - 73764.0 * np.power(n, 3) + - 73982.0 * np.power(n, 4) + + 29418.0 * np.power(n, 5) + + 87216.0 * np.power(n, 6) + + 61598.0 * np.power(n, 7) + + 23603.0 * np.power(n, 8) + + 5292.0 * np.power(n, 9) + + 491.0 * np.power(n, 10) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 4) + ) + - ( + 0.5925925925925926 + * ( + 214.0 + + 779.0 * n + + 544.0 * np.power(n, 2) + + 151.0 * np.power(n, 3) + + 40.0 * np.power(n, 4) + ) + * S2 + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + ) + - ( + 2.3703703703703702 + * ( + 20.0 + + 85.0 * n + + 50.0 * np.power(n, 2) + + 11.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * S21 + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - ( + 0.3950617283950617 + * ( + 648.0 + + 496.0 * n + + 370.0 * np.power(n, 2) + + 725.0 * np.power(n, 3) + + 1155.0 * np.power(n, 4) + + 429.0 * np.power(n, 5) + + 65.0 * np.power(n, 6) + ) + * S3 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + 0.3950617283950617 + * ( + 448.0 + + 284.0 * n + + 1794.0 * np.power(n, 2) + + 2552.0 * np.power(n, 3) + + 1257.0 * np.power(n, 4) + + 278.0 * np.power(n, 5) + + 47.0 * np.power(n, 6) + ) + * Sm2 + ) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + ( + 1.1851851851851851 + * ( + 216.0 + - 20.0 * n + - 548.0 * np.power(n, 2) + - 511.0 * np.power(n, 3) + - 339.0 * np.power(n, 4) + - 99.0 * np.power(n, 5) + + 5.0 * np.power(n, 6) + ) + * Sm3 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 7.111111111111111 + * ( + 36.0 + - 20.0 * n + - 143.0 * np.power(n, 2) + - 61.0 * np.power(n, 3) + - 24.0 * np.power(n, 4) + - 9.0 * np.power(n, 5) + + 5.0 * np.power(n, 6) + ) + * (S1 * Sm2 - 1.0 * Sm21 + Sm3) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + 1.2020569031595942 + * ( + (49.77777777777778 * (1.0 + n + np.power(n, 2))) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + - 24.88888888888889 * S1 + ) + + 1.1851851851851851 * np.power(S1, 4) + + 19.555555555555557 * np.power(S1, 2) * S2 + + 8.88888888888889 * np.power(S2, 2) + - 46.22222222222222 * S211 + + S1 * (24.88888888888889 * S21 + 69.92592592592592 * S3) + - 3.5555555555555554 * S31 + + 71.11111111111111 * S4 + + ( + (-64.0 * (-1.0 + 2.0 * n) * S1) / ((-1.0 + n) * n) + + 42.666666666666664 * S2 + ) + * Sm2 + + 1.6449340668482262 + * ( + 5.333333333333333 * np.power(S1, 2) + + 5.333333333333333 * S2 + + 10.666666666666666 * Sm2 + ) + + (64.0 * (-1.0 + 2.0 * n) * Sm21) / ((-1.0 + n) * n) + + 7.111111111111111 * Sm4 + - 21.333333333333332 * (S2 * Sm2 - 1.0 * Sm22 + Sm4) + - 10.666666666666666 * (S1 * Sm3 - 1.0 * Sm31 + Sm4) + + 64.0 + * ( + S2 * Sm2 + - 0.5 * (np.power(S1, 2) + S2) * Sm2 + + Sm211 + - 1.0 * Sm22 + + S1 * (S1 * Sm2 - 1.0 * Sm21 + Sm3) + - 1.0 * Sm31 + + Sm4 + ) + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + ) + ) diff --git a/src/eko/matching_conditions/n3lo/agg.py b/src/eko/matching_conditions/n3lo/agg.py index 160e14fe7..e961c1fb2 100644 --- a/src/eko/matching_conditions/n3lo/agg.py +++ b/src/eko/matching_conditions/n3lo/agg.py @@ -1,21 +1,737 @@ # -*- coding: utf-8 -*- -"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" -import numba as nb +"""This module contains the |OME| agg, the experssions are taken from :cite:`Bierenbaum_2009`""" import numpy as np -from ...anomalous_dimensions import harmonics -from . import g_functions as gf +from .aggTF2 import A_ggTF2_3 -zeta2 = harmonics.zeta2 -zeta3 = harmonics.zeta3 -zeta4 = harmonics.zeta4 -zeta5 = harmonics.zeta5 -li4half = 0.517479 -li5half = 0.508401 - -@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) -def A_gg_3(n, sx, spx, nf, L): - S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] - Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] - return 0.0 +def A_gg_3(n, sx, smx, s3x, s4x, nf): + S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] + Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] + S21, Sm21 = s3x[0], s3x[2] + S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] + return ( + -0.35616500834358344 + + A_ggTF2_3(n, sx, s3x) + + 0.75 + * ( + (-19.945240467240673 * (1.0 + n + np.power(n, 2))) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + - ( + 0.24369393582936685 + * ( + 168.0 + + 784.0 * n + + 1118.0 * np.power(n, 2) + + 767.0 * np.power(n, 3) + + 631.0 * np.power(n, 4) + + 297.0 * np.power(n, 5) + + 99.0 * np.power(n, 6) + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 0.09876543209876543 + * ( + 216.0 + + 288.0 * n + - 30.0 * np.power(n, 2) + + 3556.0 * np.power(n, 3) + + 14212.0 * np.power(n, 4) + + 23815.0 * np.power(n, 5) + + 22951.0 * np.power(n, 6) + + 12778.0 * np.power(n, 7) + + 3316.0 * np.power(n, 8) + + 15.0 * np.power(n, 9) + + 3.0 * np.power(n, 10) + ) + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + + 44.0897712497317 * S1 + + ( + 0.19753086419753085 + * ( + 54.0 + - 175.0 * n + - 247.0 * np.power(n, 2) + + 256.0 * np.power(n, 3) + + 328.0 * np.power(n, 4) + ) + * S1 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2)) + + (2.6666666666666665 * np.power(S1, 2)) / (1.0 + n) + - (2.6666666666666665 * (1.0 + 2.0 * n) * S2) / (1.0 + n) + + nf + * ( + (-5.698640133497335 * (1.0 + n + np.power(n, 2))) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + - ( + 0.24369393582936685 + * ( + 48.0 + + 224.0 * n + + 358.0 * np.power(n, 2) + + 277.0 * np.power(n, 3) + + 161.0 * np.power(n, 4) + + 27.0 * np.power(n, 5) + + 9.0 * np.power(n, 6) + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 0.13168724279835392 + * ( + -108.0 + - 144.0 * n + + 15.0 * np.power(n, 2) + - 1778.0 * np.power(n, 3) + - 7235.0 * np.power(n, 4) + - 12359.0 * np.power(n, 5) + - 11927.0 * np.power(n, 6) + - 6260.0 * np.power(n, 7) + - 1142.0 * np.power(n, 8) + + 315.0 * np.power(n, 9) + + 63.0 * np.power(n, 10) + ) + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + + 12.597077499923342 * S1 + + ( + 0.13168724279835392 + * ( + 54.0 + - 175.0 * n + - 247.0 * np.power(n, 2) + + 256.0 * np.power(n, 3) + + 328.0 * np.power(n, 4) + ) + * S1 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2)) + + (1.7777777777777777 * np.power(S1, 2)) / (1.0 + n) + - (1.7777777777777777 * (1.0 + 2.0 * n) * S2) / (1.0 + n) + ) + ) + + 0.3333333333333333 + * ( + ( + -1.4621636149762012 + * ( + -84.0 + - 148.0 * n + - 245.0 * np.power(n, 2) + - 378.0 * np.power(n, 3) + - 166.0 * np.power(n, 4) + + 12.0 * np.power(n, 5) + + 86.0 * np.power(n, 6) + + 60.0 * np.power(n, 7) + + 15.0 * np.power(n, 8) + ) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 0.2222222222222222 + * ( + 288.0 + + 864.0 * n + + 1224.0 * np.power(n, 2) + - 792.0 * np.power(n, 4) + + 4546.0 * np.power(n, 5) + + 7713.0 * np.power(n, 6) + + 1150.0 * np.power(n, 7) + - 2243.0 * np.power(n, 8) + + 2758.0 * np.power(n, 9) + + 4795.0 * np.power(n, 10) + + 2346.0 * np.power(n, 11) + + 391.0 * np.power(n, 12) + ) + ) + / ((-1.0 + n) * np.power(n, 5) * np.power(1.0 + n, 5) * (2.0 + n)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * (-10.684950250307505 - 8.772981689857207 * S1) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + nf + * ( + ( + 0.7310818074881006 + * ( + 48.0 + - 80.0 * n + - 220.0 * np.power(n, 2) + - 282.0 * np.power(n, 3) + - 551.0 * np.power(n, 4) + - 258.0 * np.power(n, 5) + + 196.0 * np.power(n, 6) + + 252.0 * np.power(n, 7) + + 63.0 * np.power(n, 8) + ) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 0.024691358024691357 + * ( + 1728.0 + + 5184.0 * n + + 7344.0 * np.power(n, 2) + - 15872.0 * np.power(n, 3) + - 70928.0 * np.power(n, 4) + - 90898.0 * np.power(n, 5) + - 79041.0 * np.power(n, 6) + - 82318.0 * np.power(n, 7) + - 62269.0 * np.power(n, 8) + - 8758.0 * np.power(n, 9) + + 15013.0 * np.power(n, 10) + + 9558.0 * np.power(n, 11) + + 1593.0 * np.power(n, 12) + ) + ) + / ((-1.0 + n) * np.power(n, 5) * np.power(1.0 + n, 5) * (2.0 + n)) + + ( + 1.1851851851851851 + * (2.0 + n + np.power(n, 2)) + * ( + 86.0 + + 230.0 * n + + 224.0 * np.power(n, 2) + + 105.0 * np.power(n, 3) + + 43.0 * np.power(n, 4) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 4) * (2.0 + n)) + - ( + 1.7777777777777777 + * (2.0 + n + np.power(n, 2)) + * (16.0 + 27.0 * n + 13.0 * np.power(n, 2) + 8.0 * np.power(n, 3)) + * (np.power(S1, 2) + S2) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + -8.547960200246003 + + 8.772981689857207 * S1 + + 1.7777777777777777 * np.power(S1, 3) + + 5.333333333333333 * S1 * S2 + + 3.5555555555555554 * S3 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) + + 0.8888888888888888 + * ( + 145.94322056228512 + - ( + 1.6027425375461255 + * ( + -8.0 + - 20.0 * n + - 34.0 * np.power(n, 2) + - 79.0 * np.power(n, 3) + - 143.0 * np.power(n, 4) + - 57.0 * np.power(n, 5) + + 93.0 * np.power(n, 6) + + 96.0 * np.power(n, 7) + + 24.0 * np.power(n, 8) + ) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 3.2898681336964524 + * ( + 24.0 + + 68.0 * n + - 2.0 * np.power(n, 2) + - 205.0 * np.power(n, 3) + - 509.0 * np.power(n, 4) + - 753.0 * np.power(n, 5) + - 615.0 * np.power(n, 6) + - 66.0 * np.power(n, 7) + + 282.0 * np.power(n, 8) + + 200.0 * np.power(n, 9) + + 40.0 * np.power(n, 10) + ) + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + - ( + 1.0 + * ( + 32.0 + + 208.0 * n + + 280.0 * np.power(n, 2) + - 532.0 * np.power(n, 3) + - 1944.0 * np.power(n, 4) + - 1520.0 * np.power(n, 5) + + 2258.0 * np.power(n, 6) + + 6555.0 * np.power(n, 7) + + 6707.0 * np.power(n, 8) + + 3479.0 * np.power(n, 9) + + 1343.0 * np.power(n, 10) + + 1025.0 * np.power(n, 11) + + 741.0 * np.power(n, 12) + + 273.0 * np.power(n, 13) + + 39.0 * np.power(n, 14) + ) + ) + / ((-1.0 + n) * np.power(n, 6) * np.power(1.0 + n, 6) * (2.0 + n)) + - ( + 6.579736267392905 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 + - 10.0 * n + + np.power(n, 2) + + 4.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 8.0 + * (2.0 + n + np.power(n, 2)) + * ( + -12.0 + - 44.0 * n + - 19.0 * np.power(n, 2) + - 11.0 * np.power(n, 3) + - 2.0 * np.power(n, 4) + + 2.0 * np.power(n, 5) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 4) * (2.0 + n)) + + ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -4.0 + - 18.0 * n + - 32.0 * np.power(n, 2) + - 5.0 * np.power(n, 3) + + np.power(n, 4) + ) + * np.power(S1, 2) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 + - 20.0 * n + - 56.0 * np.power(n, 2) + - 64.0 * np.power(n, 3) + + 15.0 * np.power(n, 4) + + 30.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + ) + * S2 + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + + ( + (2.0 + 3.0 * n) + * (2.0 + n + np.power(n, 2)) + * (2.6666666666666665 * np.power(S1, 3) + 8.0 * S1 * S2) + ) + / ((-1.0 + n) * np.power(n, 3) * (1.0 + n) * (2.0 + n)) + - ( + 32.0 + * (-2.0 - 3.0 * n + np.power(n, 2)) + * (2.0 + n + np.power(n, 2)) + * S21 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 2.6666666666666665 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 + - 22.0 * n + + 43.0 * np.power(n, 2) + + 48.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + * S3 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + -6.410970150184502 * S1 + - 0.6666666666666666 * np.power(S1, 4) + - 4.0 * np.power(S1, 2) * S2 + - 2.0 * np.power(S2, 2) + + 1.6449340668482262 * (-4.0 * np.power(S1, 2) + 12.0 * S2) + + 64.0 * S211 + + S1 * (-32.0 * S21 - 5.333333333333333 * S3) + - 32.0 * S31 + + 12.0 * S4 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 4.5 + * ( + ( + -0.03292181069958848 + * ( + -1188.0 + - 1584.0 * n + + 165.0 * np.power(n, 2) + - 18010.0 * np.power(n, 3) + - 73393.0 * np.power(n, 4) + - 125113.0 * np.power(n, 5) + - 120361.0 * np.power(n, 6) + - 62668.0 * np.power(n, 7) + - 11014.0 * np.power(n, 8) + + 3465.0 * np.power(n, 9) + + 693.0 * np.power(n, 10) + ) + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + + ( + 0.24369393582936685 + * ( + -576.0 + - 2544.0 * n + - 5824.0 * np.power(n, 2) + - 8400.0 * np.power(n, 3) + - 4984.0 * np.power(n, 4) + + 211.0 * np.power(n, 5) + + 2207.0 * np.power(n, 6) + + 2155.0 * np.power(n, 7) + + 1356.0 * np.power(n, 8) + + 631.0 * np.power(n, 9) + + 189.0 * np.power(n, 10) + + 27.0 * np.power(n, 11) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - 7.835630183558836 * S1 + - ( + 0.03292181069958848 + * ( + 594.0 + - 1151.0 * n + - 1943.0 * np.power(n, 2) + + 2042.0 * np.power(n, 3) + + 2834.0 * np.power(n, 4) + ) + * S1 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2)) + + ( + 0.9747757433174674 + * ( + -72.0 + - 72.0 * n + + 256.0 * np.power(n, 2) + + 292.0 * np.power(n, 3) + + 173.0 * np.power(n, 4) + + 64.0 * np.power(n, 5) + + 2.0 * np.power(n, 6) + + 4.0 * np.power(n, 7) + + np.power(n, 8) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - (4.888888888888889 * np.power(S1, 2)) / (1.0 + n) + + (4.888888888888889 * (1.0 + 2.0 * n) * S2) / (1.0 + n) + + ( + (1.0 + n + np.power(n, 2)) + * ( + 15.671260367117672 + + 1.6449340668482262 + * (21.333333333333332 * S2 + 21.333333333333332 * Sm2) + ) + ) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + + 1.6449340668482262 + * ( + -10.666666666666666 * S1 * S2 + - 5.333333333333333 * S3 + - 10.666666666666666 * S1 * Sm2 + + 10.666666666666666 * Sm21 + - 5.333333333333333 * Sm3 + ) + ) + + 2.0 + * ( + -72.97161028114256 + + ( + 1.0684950250307503 + * ( + -48.0 + - 184.0 * n + - 504.0 * np.power(n, 2) + - 72.0 * np.power(n, 3) + + 162.0 * np.power(n, 4) + + 101.0 * np.power(n, 5) + - 167.0 * np.power(n, 6) + - 91.0 * np.power(n, 7) + + 119.0 * np.power(n, 8) + + 90.0 * np.power(n, 9) + + 18.0 * np.power(n, 10) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 0.7310818074881006 + * ( + -864.0 + - 2544.0 * n + - 3344.0 * np.power(n, 2) + - 5880.0 * np.power(n, 3) + - 5230.0 * np.power(n, 4) + - 7911.0 * np.power(n, 5) + - 12524.0 * np.power(n, 6) + - 9220.0 * np.power(n, 7) + - 1680.0 * np.power(n, 8) + + 2042.0 * np.power(n, 9) + + 1562.0 * np.power(n, 10) + + 530.0 * np.power(n, 11) + + 120.0 * np.power(n, 12) + + 15.0 * np.power(n, 13) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 0.05555555555555555 + * ( + 18432.0 + + 104448.0 * n + + 305664.0 * np.power(n, 2) + + 574464.0 * np.power(n, 3) + + 807552.0 * np.power(n, 4) + + 1.160704e6 * np.power(n, 5) + + 952768.0 * np.power(n, 6) + - 227344.0 * np.power(n, 7) + - 85568.0 * np.power(n, 8) + + 2.284064e6 * np.power(n, 9) + + 2.719198e6 * np.power(n, 10) + - 792201.0 * np.power(n, 11) + - 3.594388e6 * np.power(n, 12) + - 2.371724e6 * np.power(n, 13) + + 244448.0 * np.power(n, 14) + + 1.224418e6 * np.power(n, 15) + + 794084.0 * np.power(n, 16) + + 257636.0 * np.power(n, 17) + + 43890.0 * np.power(n, 18) + + 3135.0 * np.power(n, 19) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 6) + * np.power(1.0 + n, 6) + * np.power(2.0 + n, 5) + ) + - ( + 2.193245422464302 + * ( + 48.0 + + 184.0 * n + + 144.0 * np.power(n, 2) + - 78.0 * np.power(n, 3) + - 39.0 * np.power(n, 4) + - 368.0 * np.power(n, 5) + - 586.0 * np.power(n, 6) + - 224.0 * np.power(n, 7) + + 163.0 * np.power(n, 8) + + 150.0 * np.power(n, 9) + + 30.0 * np.power(n, 10) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 0.2222222222222222 + * ( + -2304.0 + - 6336.0 * n + - 34832.0 * np.power(n, 2) + - 91776.0 * np.power(n, 3) + - 141176.0 * np.power(n, 4) + - 137724.0 * np.power(n, 5) + - 69461.0 * np.power(n, 6) + + 12096.0 * np.power(n, 7) + + 46703.0 * np.power(n, 8) + + 34680.0 * np.power(n, 9) + + 13349.0 * np.power(n, 10) + + 2724.0 * np.power(n, 11) + + 233.0 * np.power(n, 12) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 + + 16.0 * n + + 18.0 * np.power(n, 2) + + 4.0 * np.power(n, 3) + + 7.0 * np.power(n, 4) + + 6.0 * np.power(n, 5) + + np.power(n, 6) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 2.6666666666666665 + * (2.0 + n + np.power(n, 2)) + * (2.0 + 11.0 * n + 8.0 * np.power(n, 2) + np.power(n, 3)) + * np.power(S1, 3) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + 64.0 + + 256.0 * n + + 456.0 * np.power(n, 2) + + 600.0 * np.power(n, 3) + + 290.0 * np.power(n, 4) + + 42.0 * np.power(n, 5) + + 105.0 * np.power(n, 6) + + 85.0 * np.power(n, 7) + + 21.0 * np.power(n, 8) + + np.power(n, 9) + ) + * S2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 8.0 + * (2.0 + n + np.power(n, 2)) + * (-2.0 - 27.0 * n - 12.0 * np.power(n, 2) + 3.0 * np.power(n, 3)) + * S1 + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 21.333333333333332 + * (2.0 + n + np.power(n, 2)) + * ( + 6.0 + + 7.0 * n + + 3.0 * np.power(n, 2) + + 9.0 * np.power(n, 3) + + 10.0 * np.power(n, 4) + + np.power(n, 5) + ) + * S3 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + 20.0 + + 22.0 * n + + 7.0 * np.power(n, 2) + + 2.0 * np.power(n, 3) + + np.power(n, 4) + ) + * (-26.31894506957162 - 32.0 * Sm2) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + ( + (-4.0 - 1.0 * n + np.power(n, 2)) + * (2.0 + n + np.power(n, 2)) + * ( + 28.849365675830263 + + 52.63789013914324 * S1 + + 64.0 * S1 * Sm2 + - 64.0 * Sm21 + + 32.0 * Sm3 + ) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + 6.410970150184502 * S1 + + 0.6666666666666666 * np.power(S1, 4) + + 20.0 * np.power(S1, 2) * S2 + + 2.0 * np.power(S2, 2) + - 16.0 * S211 + - 16.0 * S31 + + 36.0 * S4 + + (32.0 * np.power(S1, 2) + 32.0 * S2) * Sm2 + + 1.6449340668482262 + * (4.0 * np.power(S1, 2) + 12.0 * S2 + 24.0 * Sm2) + + S1 * (53.333333333333336 * S3 - 64.0 * Sm21) + + 64.0 * Sm211 + - 32.0 * Sm22 + + 32.0 * S1 * Sm3 + - 32.0 * Sm31 + + 16.0 * Sm4 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) diff --git a/src/eko/matching_conditions/n3lo/aggTF2.py b/src/eko/matching_conditions/n3lo/aggTF2.py new file mode 100644 index 000000000..1e38dce94 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aggTF2.py @@ -0,0 +1,301 @@ +# -*- coding: utf-8 -*- +"""This module contains the |OME| aggTF2, the experssions are taken from :cite:`Bierenbaum_2009`""" +import numpy as np + +from .s_functions import binomial + + +def A_ggTF2_3(n, sx, s3x): + S1, S2, S3 = sx[0], sx[1], sx[2] + S21 = s3x[0] + return 0.3333333333333333 * ( + ( + 0.1335618781288438 + * ( + -1472.0 + - 1472.0 * n + - 1714.0 * np.power(n, 2) + - 547.0 * np.power(n, 3) + - 431.0 * np.power(n, 4) + - 189.0 * np.power(n, 5) + - 63.0 * np.power(n, 6) + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 0.00823045267489712 + * ( + 18144.0 + - 21600.0 * n + - 167688.0 * np.power(n, 2) + - 407328.0 * np.power(n, 3) + - 325576.0 * np.power(n, 4) + + 89818.0 * np.power(n, 5) + - 807075.0 * np.power(n, 6) + - 1.672874e6 * np.power(n, 7) + - 379547.0 * np.power(n, 8) + + 593774.0 * np.power(n, 9) + + 61883.0 * np.power(n, 10) + - 152862.0 * np.power(n, 11) + - 9409.0 * np.power(n, 12) + + 35472.0 * np.power(n, 13) + + 8868.0 * np.power(n, 14) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * (2.0 + n) + * (-3.0 + 2.0 * n) + * (-1.0 + 2.0 * n) + ) + + ( + 0.5925925925925926 + * ( + -24.0 + - 56.0 * n + - 100.0 * np.power(n, 2) + - 129.0 * np.power(n, 3) + - 50.0 * np.power(n, 4) + + 3.0 * np.power(n, 5) + + 4.0 * np.power(n, 6) + ) + * np.power(S1, 2) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + (0.5925925925925926 * np.power(2.0 + n + np.power(n, 2), 2) * np.power(S1, 3)) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + 1.6449340668482262 + * ( + ( + -0.8888888888888888 + * ( + 84.0 + + 148.0 * n + + 245.0 * np.power(n, 2) + + 282.0 * np.power(n, 3) + - 74.0 * np.power(n, 4) + - 108.0 * np.power(n, 5) + + 106.0 * np.power(n, 6) + + 132.0 * np.power(n, 7) + + 33.0 * np.power(n, 8) + ) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + (5.333333333333333 * np.power(2.0 + n + np.power(n, 2), 2) * S1) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - ( + 1.7777777777777777 + * ( + -24.0 + - 56.0 * n + - 100.0 * np.power(n, 2) + - 129.0 * np.power(n, 3) + - 50.0 * np.power(n, 4) + + 3.0 * np.power(n, 5) + + 4.0 * np.power(n, 6) + ) + * S2 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + S1 + * ( + ( + -0.3950617283950617 + * ( + 216.0 + + 1008.0 * n + + 2082.0 * np.power(n, 2) + + 2564.0 * np.power(n, 3) + + 2192.0 * np.power(n, 4) + + 2206.0 * np.power(n, 5) + + 1470.0 * np.power(n, 6) + + 388.0 * np.power(n, 7) + - 221.0 * np.power(n, 8) + + 136.0 * np.power(n, 9) + + 23.0 * np.power(n, 10) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * (2.0 + n) + * (-3.0 + 2.0 * n) + * (-1.0 + 2.0 * n) + ) + - (5.333333333333333 * np.power(2.0 + n + np.power(n, 2), 2) * S2) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - ( + 1.0 + * np.power(2.0 + n + np.power(n, 2), 2) + * (-21.333333333333332 * S21 + 13.037037037037036 * S3) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 2.80479944070572 + * np.power(4.0, 2.0 - 1.0 * n) + * ( + -80.0 + - 104.0 * n + + 44.0 * np.power(n, 2) + + 47.0 * np.power(n, 3) + - 53.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + + 9.0 * np.power(n, 6) + ) + * binomial(2.0 * n, n) + ) + / ( + (-1.0 + n) + * n + * np.power(1.0 + n, 2) + * (2.0 + n) + * (-3.0 + 2.0 * n) + * (-1.0 + 2.0 * n) + ) + ) + 0.75 * ( + ( + 0.00027434842249657066 + * ( + 181440.0 + - 518400.0 * n + - 1.22544e6 * np.power(n, 2) + + 2.452488e6 * np.power(n, 3) + + 2.36045e6 * np.power(n, 4) + - 1.1167685e7 * np.power(n, 5) + - 2.1164117e7 * np.power(n, 6) + - 1.4957774e7 * np.power(n, 7) + - 710852.0 * np.power(n, 8) + + 6.431215e6 * np.power(n, 9) + + 4.037555e6 * np.power(n, 10) + + 481788.0 * np.power(n, 11) + + 149796.0 * np.power(n, 12) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * (2.0 + n) + * (-3.0 + 2.0 * n) + * (-1.0 + 2.0 * n) + ) + + 1.2020569031595942 + * ( + ( + -0.025925925925925925 + * ( + -2624.0 + - 7214.0 * n + - 3047.0 * np.power(n, 2) + + 3726.0 * np.power(n, 3) + + 1287.0 * np.power(n, 4) + ) + ) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + - 41.48148148148148 * S1 + ) + + 1.6449340668482262 + * ( + ( + 0.14814814814814814 + * ( + 168.0 + + 784.0 * n + + 1118.0 * np.power(n, 2) + + 767.0 * np.power(n, 3) + + 631.0 * np.power(n, 4) + + 297.0 * np.power(n, 5) + + 99.0 * np.power(n, 6) + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - 20.74074074074074 * S1 + ) + - ( + 0.0021947873799725653 + * ( + -12960.0 + - 38880.0 * n + - 7470.0 * np.power(n, 2) + - 207066.0 * np.power(n, 3) + - 194200.0 * np.power(n, 4) + + 478087.0 * np.power(n, 5) + + 196513.0 * np.power(n, 6) + - 563492.0 * np.power(n, 7) + - 293651.0 * np.power(n, 8) + + 180403.0 * np.power(n, 9) + + 96020.0 * np.power(n, 10) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * (2.0 + n) + * (-3.0 + 2.0 * n) + * (-1.0 + 2.0 * n) + ) + - ( + 0.02962962962962963 + * ( + -142.0 + - 629.0 * n + - 751.0 * np.power(n, 2) + - 223.0 * np.power(n, 3) + + 95.0 * np.power(n, 4) + + 70.0 * np.power(n, 5) + ) + * np.power(S1, 2) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 0.02962962962962963 + * ( + -462.0 + - 1329.0 * n + - 1621.0 * np.power(n, 2) + - 883.0 * np.power(n, 3) + - 135.0 * np.power(n, 4) + + 550.0 * np.power(n, 5) + + 220.0 * np.power(n, 6) + ) + * S2 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 1.0666666666666667 + * (1.0 - 7.0 * n + 4.0 * np.power(n, 2) + 4.0 * np.power(n, 3)) + * (S21 - 1.0 * S3) + ) + / ((-1.0 + n) * n * (1.0 + n)) + + ( + 0.18698662938038133 + * np.power(4.0, 1.0 - 1.0 * n) + * ( + 996.0 + + 712.0 * n + - 1495.0 * np.power(n, 2) + + 219.0 * np.power(n, 3) + + 452.0 * np.power(n, 4) + - 2094.0 * np.power(n, 5) + + 283.0 * np.power(n, 6) + + 539.0 * np.power(n, 7) + + 100.0 * np.power(n, 8) + ) + * binomial(2.0 * n, n) + ) + / ( + (-1.0 + n) + * n + * np.power(1.0 + n, 2) + * (2.0 + n) + * (-3.0 + 2.0 * n) + * (-1.0 + 2.0 * n) + ) + ) diff --git a/src/eko/matching_conditions/n3lo/agq.py b/src/eko/matching_conditions/n3lo/agq.py index c295304de..07e473409 100644 --- a/src/eko/matching_conditions/n3lo/agq.py +++ b/src/eko/matching_conditions/n3lo/agq.py @@ -1,21 +1,604 @@ # -*- coding: utf-8 -*- -"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +"""This module contains the |OME| agq, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np -from ...anomalous_dimensions import harmonics -from . import g_functions as gf -zeta2 = harmonics.zeta2 -zeta3 = harmonics.zeta3 -zeta4 = harmonics.zeta4 -zeta5 = harmonics.zeta5 -li4half = 0.517479 -li5half = 0.508401 - - -@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) -def A_gq_3(n, sx, spx, nf, L): - S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] - Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] - return 0.0 +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) +def A_gq_3(n, sx, smx, s3x, s4x, nf): + S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] + Sm1, Sm2, Sm3, Sm4 = smx[0], smx[1], smx[2], smx[3] + S21, S2m1, Sm21, Sm2m1 = s3x[0], s3x[1], s3x[2], s3x[3] + S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] + return ( + 0.3333333333333333 + * ( + ( + -0.06584362139917696 + * ( + 718.0 + + 2495.0 * n + + 3608.0 * np.power(n, 2) + + 2944.0 * np.power(n, 3) + + 1364.0 * np.power(n, 4) + + 359.0 * np.power(n, 5) + ) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 4)) + + ( + 1.1851851851851851 + * ( + 8.0 + + 25.0 * n + + 23.0 * np.power(n, 2) + + 4.0 * np.power(n, 3) + + 4.0 * np.power(n, 4) + ) + * S1 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 3)) + - ( + 0.5925925925925926 + * (16.0 + 27.0 * n + 13.0 * np.power(n, 2) + 8.0 * np.power(n, 3)) + * np.power(S1, 2) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2)) + - ( + 0.5925925925925926 + * (16.0 + 27.0 * n + 13.0 * np.power(n, 2) + 8.0 * np.power(n, 3)) + * S2 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2)) + + nf + * ( + ( + 0.26337448559670784 + * ( + 394.0 + + 1388.0 * n + + 1961.0 * np.power(n, 2) + + 1540.0 * np.power(n, 3) + + 824.0 * np.power(n, 4) + + 197.0 * np.power(n, 5) + ) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 4)) + + ( + 2.3703703703703702 + * ( + 8.0 + + 25.0 * n + + 23.0 * np.power(n, 2) + + 4.0 * np.power(n, 3) + + 4.0 * np.power(n, 4) + ) + * S1 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 3)) + - ( + 1.1851851851851851 + * (16.0 + 27.0 * n + 13.0 * np.power(n, 2) + 8.0 * np.power(n, 3)) + * np.power(S1, 2) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2)) + - ( + 1.1851851851851851 + * (16.0 + 27.0 * n + 13.0 * np.power(n, 2) + 8.0 * np.power(n, 3)) + * S2 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2)) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + 59.835721401722026 + + 0.5925925925925926 * np.power(S1, 3) + + 1.7777777777777777 * S1 * S2 + + 1.1851851851851851 * S3 + + nf + * ( + -34.19184080098401 + + 1.1851851851851851 * np.power(S1, 3) + + 3.5555555555555554 * S1 * S2 + + 2.3703703703703702 * S3 + ) + ) + ) + / ((-1.0 + n) * n * (1.0 + n)) + ) + + 0.8888888888888888 + * ( + ( + 1.0684950250307503 + * ( + 192.0 + + 608.0 * n + + 436.0 * np.power(n, 2) + - 280.0 * np.power(n, 3) + - 33.0 * np.power(n, 4) + + 436.0 * np.power(n, 5) + + 730.0 * np.power(n, 6) + + 484.0 * np.power(n, 7) + + 115.0 * np.power(n, 8) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * (2.0 + n) + ) + + ( + 0.00205761316872428 + * ( + 718848.0 + + 3.036672e6 * n + + 7.448064e6 * np.power(n, 2) + + 3.6681856e7 * np.power(n, 3) + + 9.6114752e7 * np.power(n, 4) + + 9.0199968e7 * np.power(n, 5) + - 3.1178992e7 * np.power(n, 6) + - 1.39149336e8 * np.power(n, 7) + - 1.06346044e8 * np.power(n, 8) + + 2.390668e7 * np.power(n, 9) + + 1.19019157e8 * np.power(n, 10) + + 1.13250363e8 * np.power(n, 11) + + 4.9867573e7 * np.power(n, 12) + + 794307.0 * np.power(n, 13) + - 1.1396201e7 * np.power(n, 14) + - 6.177407e6 * np.power(n, 15) + - 1.469301e6 * np.power(n, 16) + - 138495.0 * np.power(n, 17) + ) + ) + / ( + (-2.0 + n) + * np.power(-1.0 + n, 2) + * np.power(n, 5) + * np.power(1.0 + n, 6) + * np.power(2.0 + n, 4) + ) + - ( + 0.09876543209876543 + * ( + -72.0 + - 456.0 * n + - 847.0 * np.power(n, 2) + - 694.0 * np.power(n, 3) + - 343.0 * np.power(n, 4) + - 216.0 * np.power(n, 5) + + 4.0 * np.power(n, 6) + ) + * np.power(S1, 2) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3)) + + ( + 0.49382716049382713 + * (-6.0 + 11.0 * n + np.power(n, 2) + 4.0 * np.power(n, 3)) + * np.power(S1, 3) + ) + / ((-1.0 + n) * np.power(n, 2) * (1.0 + n)) + - ( + 0.09876543209876543 + * ( + -5184.0 + - 7776.0 * n + - 8496.0 * np.power(n, 2) + - 6172.0 * np.power(n, 3) + + 21932.0 * np.power(n, 4) + + 14047.0 * np.power(n, 5) + - 14788.0 * np.power(n, 6) + - 20968.0 * np.power(n, 7) + - 8170.0 * np.power(n, 8) + + 297.0 * np.power(n, 9) + + 3042.0 * np.power(n, 10) + + 1132.0 * np.power(n, 11) + ) + * S2 + ) + / ( + (-2.0 + n) + * np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * (2.0 + n) + ) + + S1 + * ( + ( + 0.06584362139917696 + * ( + -108.0 + - 1008.0 * n + - 4161.0 * np.power(n, 2) + - 6041.0 * np.power(n, 3) + - 1186.0 * np.power(n, 4) + + 5051.0 * np.power(n, 5) + + 5986.0 * np.power(n, 6) + + 3236.0 * np.power(n, 7) + + 1031.0 * np.power(n, 8) + ) + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4)) + + ( + 0.2962962962962963 + * ( + 18.0 + + 341.0 * n + + 546.0 * np.power(n, 2) + + 293.0 * np.power(n, 3) + + 166.0 * np.power(n, 4) + ) + * S2 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2)) + ) + - ( + 0.5925925925925926 + * (70.0 + 111.0 * n + 64.0 * np.power(n, 2) + 35.0 * np.power(n, 3)) + * S21 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2)) + + ( + 0.19753086419753085 + * ( + -876.0 + - 1532.0 * n + - 1631.0 * np.power(n, 2) + + 434.0 * np.power(n, 3) + + 828.0 * np.power(n, 4) + + 774.0 * np.power(n, 5) + + 275.0 * np.power(n, 6) + ) + * S3 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * (2.0 + n) + ) + - ( + 10.666666666666666 + * ( + 64.0 + + 120.0 * n + - 16.0 * np.power(n, 2) + - 2.0 * np.power(n, 3) + + 3.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + + 3.0 * np.power(n, 7) + + np.power(n, 8) + ) + * Sm2 + ) + / ( + (-2.0 + n) + * np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + -141.50943229384302 + + 0.37037037037037035 * np.power(S1, 4) + - 8.444444444444445 * np.power(S1, 2) * S2 + - 0.6666666666666666 * np.power(S2, 2) + - 3.5555555555555554 * S211 + - (128.0 * S2m1) / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + + S1 + * ( + 42.73980100123002 + + 3.5555555555555554 * S21 + - 11.25925925925926 * S3 + ) + + 10.666666666666666 * S31 + - 19.11111111111111 * S4 + + (128.0 * S2 * Sm1) / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + - (128.0 * Sm1 * Sm2) / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + + (128.0 * Sm2m1) / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + + (42.666666666666664 * Sm3) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + ) + ) + / ((-1.0 + n) * n * (1.0 + n)) + ) + + 2.0 + * ( + ( + -0.5342475125153752 + * ( + 1120.0 + - 172.0 * n + + 1084.0 * np.power(n, 2) + - 253.0 * np.power(n, 3) + + 65.0 * np.power(n, 4) + + 249.0 * np.power(n, 5) + + 19.0 * np.power(n, 6) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * (2.0 + n) + ) + + ( + 0.03292181069958848 + * ( + -6912.0 + - 47232.0 * n + - 441984.0 * np.power(n, 2) + - 1.844224e6 * np.power(n, 3) + - 3.89016e6 * np.power(n, 4) + - 4.766232e6 * np.power(n, 5) + - 3.300816e6 * np.power(n, 6) + - 574564.0 * np.power(n, 7) + + 1.086304e6 * np.power(n, 8) + + 625443.0 * np.power(n, 9) + - 386836.0 * np.power(n, 10) + - 504489.0 * np.power(n, 11) + - 121050.0 * np.power(n, 12) + + 88963.0 * np.power(n, 13) + + 76658.0 * np.power(n, 14) + + 23287.0 * np.power(n, 15) + + 2596.0 * np.power(n, 16) + ) + ) + / ( + (-2.0 + n) + * np.power(-1.0 + n, 2) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + + ( + 0.04938271604938271 + * ( + 1152.0 + - 4752.0 * n + - 17128.0 * np.power(n, 2) + - 7888.0 * np.power(n, 3) + + 16190.0 * np.power(n, 4) + + 22753.0 * np.power(n, 5) + + 12689.0 * np.power(n, 6) + + 5119.0 * np.power(n, 7) + + 1821.0 * np.power(n, 8) + + 284.0 * np.power(n, 9) + ) + * np.power(S1, 2) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 0.19753086419753085 + * ( + -150.0 + - 1.0 * n + + 165.0 * np.power(n, 2) + + 49.0 * np.power(n, 3) + + 23.0 * np.power(n, 4) + + 4.0 * np.power(n, 5) + ) + * np.power(S1, 3) + ) + / (np.power(-1.0 + n, 2) * np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - ( + 0.14814814814814814 + * ( + 4608.0 + + 5984.0 * n + + 2528.0 * np.power(n, 2) + + 10352.0 * np.power(n, 3) + + 10204.0 * np.power(n, 4) + + 434.0 * np.power(n, 5) + - 1853.0 * np.power(n, 6) + - 759.0 * np.power(n, 7) + - 265.0 * np.power(n, 8) + + 81.0 * np.power(n, 9) + + 78.0 * np.power(n, 10) + ) + * S2 + ) + / ( + (-2.0 + n) + * np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + S1 + * ( + ( + -0.03292181069958848 + * ( + 3456.0 + + 33984.0 * n + + 39648.0 * np.power(n, 2) + - 118240.0 * np.power(n, 3) + - 256840.0 * np.power(n, 4) + - 15780.0 * np.power(n, 5) + + 382214.0 * np.power(n, 6) + + 482244.0 * np.power(n, 7) + + 299724.0 * np.power(n, 8) + + 120121.0 * np.power(n, 9) + + 39379.0 * np.power(n, 10) + + 10131.0 * np.power(n, 11) + + 1207.0 * np.power(n, 12) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 0.5925925925925926 + * ( + -66.0 + - 7.0 * n + - 283.0 * np.power(n, 2) + + 19.0 * np.power(n, 3) + + 72.0 * np.power(n, 4) + + 54.0 * np.power(n, 5) + + 31.0 * np.power(n, 6) + ) + * S2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * (2.0 + n) + ) + ) + + ( + 1.7777777777777777 + * ( + 88.0 + - 10.0 * n + + 81.0 * np.power(n, 2) + + 4.0 * np.power(n, 3) + + 15.0 * np.power(n, 4) + + 14.0 * np.power(n, 5) + ) + * S21 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * (2.0 + n) + ) + + ( + 0.09876543209876543 + * ( + 24.0 + - 356.0 * n + - 2066.0 * np.power(n, 2) + + 725.0 * np.power(n, 3) + + 981.0 * np.power(n, 4) + + 567.0 * np.power(n, 5) + + 269.0 * np.power(n, 6) + ) + * S3 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * (2.0 + n) + ) + + ( + ( + -0.5925925925925926 + * ( + -960.0 + - 1304.0 * n + + 3640.0 * np.power(n, 2) + + 5838.0 * np.power(n, 3) + + 1254.0 * np.power(n, 4) + - 5032.0 * np.power(n, 5) + - 4499.0 * np.power(n, 6) + - 1445.0 * np.power(n, 7) + + 285.0 * np.power(n, 8) + + 503.0 * np.power(n, 9) + + 136.0 * np.power(n, 10) + ) + ) + / ( + (-2.0 + n) + * np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 1.1851851851851851 + * ( + 36.0 + + 137.0 * n + + 210.0 * np.power(n, 2) + + 95.0 * np.power(n, 3) + + 52.0 * np.power(n, 4) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2)) + ) + * Sm2 + - ( + 1.1851851851851851 + * ( + 36.0 + + 85.0 * n + + 126.0 * np.power(n, 2) + + 49.0 * np.power(n, 3) + + 26.0 * np.power(n, 4) + ) + * Sm21 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2)) + + ( + 0.5925925925925926 + * ( + -192.0 + - 334.0 * n + - 373.0 * np.power(n, 2) + + 253.0 * np.power(n, 3) + + 291.0 * np.power(n, 4) + + 159.0 * np.power(n, 5) + + 52.0 * np.power(n, 6) + ) + * Sm3 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * (2.0 + n) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + 122.70623136505614 + - 0.37037037037037035 * np.power(S1, 4) + - 7.555555555555555 * np.power(S1, 2) * S2 + - 13.555555555555555 * np.power(S2, 2) + + 16.0 * S211 + + (64.0 * S2m1) / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + + 10.666666666666666 * S31 + - 39.55555555555556 * S4 + - (64.0 * S2 * Sm1) / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + + ( + -19.555555555555557 * np.power(S1, 2) + - 19.555555555555557 * S2 + + (64.0 * Sm1) / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + ) + * Sm2 + - 3.5555555555555554 * np.power(Sm2, 2) + + S1 + * ( + -17.095920400492005 + - 7.111111111111111 * S21 + - 27.85185185185185 * S3 + + 32.0 * Sm21 + ) + - 39.111111111111114 * Sm211 + + 24.88888888888889 * Sm22 + - (64.0 * Sm2m1) / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + - 33.77777777777778 * S1 * Sm3 + + 30.22222222222222 * Sm31 + - 35.55555555555556 * Sm4 + ) + ) + / ((-1.0 + n) * n * (1.0 + n)) + ) + ) From 81abc2d07033cc122a6df6c4cd114c22ecbd6d99 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Wed, 29 Sep 2021 15:09:18 +0200 Subject: [PATCH 37/71] Adding quark NS, PS and qg OME --- src/eko/matching_conditions/n3lo/aqg.py | 246 ++++++++- src/eko/matching_conditions/n3lo/aqqNS.py | 634 +++++++++++++++++++++- src/eko/matching_conditions/n3lo/aqqPS.py | 103 +++- 3 files changed, 937 insertions(+), 46 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/aqg.py b/src/eko/matching_conditions/n3lo/aqg.py index caeb5d4b8..16d60a3fa 100644 --- a/src/eko/matching_conditions/n3lo/aqg.py +++ b/src/eko/matching_conditions/n3lo/aqg.py @@ -1,21 +1,235 @@ # -*- coding: utf-8 -*- -"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +"""This module contains the |OME| aqg, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np -from ...anomalous_dimensions import harmonics -from . import g_functions as gf -zeta2 = harmonics.zeta2 -zeta3 = harmonics.zeta3 -zeta4 = harmonics.zeta4 -zeta5 = harmonics.zeta5 -li4half = 0.517479 -li5half = 0.508401 - - -@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) -def A_qg_3(n, sx, spx, nf, L): - S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] - Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] - return 0.0 +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) +def A_qg_3(n, sx, smx, s3x, s4x, nf): + S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] + Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] + S21 = s3x[0] + S31, S211 = s4x[0], s4x[1] + return 0.3333333333333333 * nf * ( + ( + -8.547960200246003 + * (2.0 + n + np.power(n, 2)) + * ( + -24.0 + - 28.0 * n + - 38.0 * np.power(n, 2) + - 17.0 * np.power(n, 3) + - 1.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + ) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + + ( + 0.00411522633744856 + * ( + 995328.0 + + 5.612544e6 * n + + 1.5388416e7 * np.power(n, 2) + + 2.6395008e7 * np.power(n, 3) + + 2.9337472e7 * np.power(n, 4) + + 2.2643488e7 * np.power(n, 5) + + 1.6104128e7 * np.power(n, 6) + + 1.3846104e7 * np.power(n, 7) + + 1.1303496e7 * np.power(n, 8) + + 1.1536274e7 * np.power(n, 9) + + 1.7070917e7 * np.power(n, 10) + + 2.0248499e7 * np.power(n, 11) + + 1.6391845e7 * np.power(n, 12) + + 9.348807e6 * np.power(n, 13) + + 3.812487e6 * np.power(n, 14) + + 1.064857e6 * np.power(n, 15) + + 180999.0 * np.power(n, 16) + + 13923.0 * np.power(n, 17) + ) + ) + / ((-1.0 + n) * np.power(n, 6) * np.power(1.0 + n, 6) * np.power(2.0 + n, 5)) + - ( + 0.06584362139917696 + * ( + 1344.0 + + 7930.0 * n + + 14077.0 * np.power(n, 2) + + 11200.0 * np.power(n, 3) + + 5124.0 * np.power(n, 4) + + 1523.0 * np.power(n, 5) + ) + * S1 + ) + / (np.power(n, 2) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 0.09876543209876543 + * ( + 120.0 + + 748.0 * n + + 930.0 * np.power(n, 2) + + 481.0 * np.power(n, 3) + + 215.0 * np.power(n, 4) + ) + * np.power(S1, 2) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 0.2962962962962963 + * ( + 40.0 + + 324.0 * n + + 478.0 * np.power(n, 2) + + 291.0 * np.power(n, 3) + + 109.0 * np.power(n, 4) + ) + * S2 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + (6.0 + 29.0 * n + 13.0 * np.power(n, 2) + 10.0 * np.power(n, 3)) + * (-0.19753086419753085 * np.power(S1, 3) - 0.5925925925925926 * S1 * S2) + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + + ( + 0.3950617283950617 + * (-6.0 + n - 16.0 * np.power(n, 2) + 5.0 * np.power(n, 3)) + * S3 + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -8.547960200246003 * S1 + - 0.037037037037037035 * np.power(S1, 4) + - 0.2222222222222222 * np.power(S1, 2) * S2 + - 0.1111111111111111 * np.power(S2, 2) + - 0.2962962962962963 * S1 * S3 + + 1.5555555555555556 * S4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + 0.75 * nf * ( + (68.38368160196802 * (1.0 + n + np.power(n, 2)) * (2.0 + n + np.power(n, 2))) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + 0.03292181069958848 + * ( + -34560.0 + - 160128.0 * n + - 264192.0 * np.power(n, 2) + - 217952.0 * np.power(n, 3) + - 499824.0 * np.power(n, 4) + - 1.907512e6 * np.power(n, 5) + - 4.373672e6 * np.power(n, 6) + - 6.333994e6 * np.power(n, 7) + - 6.01512e6 * np.power(n, 8) + - 3.525799e6 * np.power(n, 9) + - 860568.0 * np.power(n, 10) + + 416251.0 * np.power(n, 11) + + 471164.0 * np.power(n, 12) + + 194011.0 * np.power(n, 13) + + 39780.0 * np.power(n, 14) + + 3315.0 * np.power(n, 15) + ) + ) + / ((-1.0 + n) * np.power(n, 5) * np.power(1.0 + n, 5) * np.power(2.0 + n, 5)) + + ( + 0.06584362139917696 + * ( + 864.0 + - 11264.0 * n + - 64352.0 * np.power(n, 2) + - 115200.0 * np.power(n, 3) + - 69902.0 * np.power(n, 4) + + 49344.0 * np.power(n, 5) + + 114495.0 * np.power(n, 6) + + 90323.0 * np.power(n, 7) + + 40547.0 * np.power(n, 8) + + 10557.0 * np.power(n, 9) + + 1244.0 * np.power(n, 10) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + - ( + 0.19753086419753085 + * ( + 680.0 + + 2704.0 * n + + 4494.0 * np.power(n, 2) + + 3991.0 * np.power(n, 3) + + 2148.0 * np.power(n, 4) + + 694.0 * np.power(n, 5) + + 103.0 * np.power(n, 6) + ) + * np.power(S1, 2) + ) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - ( + 0.19753086419753085 + * ( + 752.0 + + 3220.0 * n + + 5724.0 * np.power(n, 2) + + 5776.0 * np.power(n, 3) + + 3438.0 * np.power(n, 4) + + 1093.0 * np.power(n, 5) + + 139.0 * np.power(n, 6) + ) + * S2 + ) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + ( + ( + 20.0 + + 49.0 * n + + 41.0 * np.power(n, 2) + + 20.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * ( + 0.3950617283950617 * np.power(S1, 3) + - 1.1851851851851851 * S1 * S2 + + 4.7407407407407405 * S21 + ) + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + 0.7901234567901234 + * ( + 20.0 + + 31.0 * n + + 59.0 * np.power(n, 2) + + 38.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * S3 + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - ( + 0.3950617283950617 + * (224.0 + 414.0 * n + 293.0 * np.power(n, 2) + 121.0 * np.power(n, 3)) + * Sm2 + ) + / (n * np.power(1.0 + n, 2) * (2.0 + n)) + + (4.7407407407407405 * (10.0 + 8.0 * n + 5.0 * np.power(n, 2)) * Sm3) + / (n * (1.0 + n) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + 8.547960200246003 * S1 + + 0.037037037037037035 * np.power(S1, 4) + - 0.2222222222222222 * np.power(S1, 2) * S2 + + 0.1111111111111111 * np.power(S2, 2) + - 1.7777777777777777 * S211 + + S1 * (1.7777777777777777 * S21 - 1.4814814814814814 * S3) + + 3.5555555555555554 * S31 + + 1.5555555555555556 * S4 + + 3.5555555555555554 * Sm4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) diff --git a/src/eko/matching_conditions/n3lo/aqqNS.py b/src/eko/matching_conditions/n3lo/aqqNS.py index a3cca3ca6..d3387dbe4 100644 --- a/src/eko/matching_conditions/n3lo/aqqNS.py +++ b/src/eko/matching_conditions/n3lo/aqqNS.py @@ -1,21 +1,627 @@ # -*- coding: utf-8 -*- -"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +"""This module contains the |OME| aqqNS, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np -from ...anomalous_dimensions import harmonics -from . import g_functions as gf +from . import s_functions as sf -zeta2 = harmonics.zeta2 -zeta3 = harmonics.zeta3 -zeta4 = harmonics.zeta4 -zeta5 = harmonics.zeta5 -li4half = 0.517479 -li5half = 0.508401 - -@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) -def A_qqNS_3(n, sx, spx, nf, L): +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) +def A_qqNS_3(n, sx, smx, s3x, s4x, nf): S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] - Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] - return 0.0 + Sm1, Sm2, Sm3, Sm4, Sm5 = smx[0], smx[1], smx[2], smx[3], smx[4] + S21, S2m1, Sm21 = s3x[0], s3x[1], s3x[2] + S31, S211, Sm22, Sm211 = s4x[0], s4x[1], s4x[2], s4x[3] + S41 = sf.harmonic_S41(n, S1, S2, S3) + S311 = sf.harmonic_S311(n, S1, S2) + S221 = sf.harmonic_S221(n, S1, S2, S21) + Sm221 = sf.harmonic_Sm221(n, S1, Sm1, S21, Sm21) + S21m2 = sf.harmonic_S21m2(n, S1, S2, Sm1, Sm2, Sm3, S21, Sm21, S2m1) + S2111 = sf.harmonic_S2111(n, S1, S2, S3) + Sm2111 = sf.harmonic_Sm2111(n, S1, S2, S3, Sm1) + S23 = sf.harmonic_S23(n, S1, S2, S3) + Sm23 = sf.harmonic_Sm23(n, Sm1, Sm2, Sm3) + S2m3 = sf.harmonic_S2m3(n, S2, Sm1, Sm2, Sm3) + return ( + 0.3333333333333333 + * nf + * ( + ( + 0.0054869684499314125 + * ( + 432.0 + + 144.0 * n + - 2016.0 * np.power(n, 2) + + 1712.0 * np.power(n, 3) + + 15165.0 * np.power(n, 4) + + 25380.0 * np.power(n, 5) + + 23870.0 * np.power(n, 6) + + 14196.0 * np.power(n, 7) + + 3549.0 * np.power(n, 8) + ) + ) + / (np.power(n, 4) * np.power(1.0 + n, 4)) + - 33.00960219478738 * S1 + + 11.39728026699467 + * ( + (-0.5 * (2.0 + 3.0 * n + 3.0 * np.power(n, 2))) / (n * (1.0 + n)) + + 2.0 * S1 + ) + + 1.5802469135802468 * S2 + + 7.901234567901234 * S3 + - 4.7407407407407405 * S4 + ) + + 0.3333333333333333 + * ( + ( + -0.0027434842249657062 + * ( + -432.0 + - 144.0 * n + + 2016.0 * np.power(n, 2) + + 4312.0 * np.power(n, 3) + + 11943.0 * np.power(n, 4) + + 28836.0 * np.power(n, 5) + + 36370.0 * np.power(n, 6) + + 21948.0 * np.power(n, 7) + + 5487.0 * np.power(n, 8) + ) + ) + / (np.power(n, 4) * np.power(1.0 + n, 4)) + + 16.54869684499314 * S1 + - 19.945240467240673 + * ( + (-0.5 * (2.0 + 3.0 * n + 3.0 * np.power(n, 2))) / (n * (1.0 + n)) + + 2.0 * S1 + ) + + 0.7901234567901234 * S2 + + 3.950617283950617 * S3 + - 2.3703703703703702 * S4 + ) + + 2.0 + * ( + ( + 0.09876543209876543 + * ( + 72.0 + + 132.0 * n + + 101.0 * np.power(n, 2) + + 485.0 * np.power(n, 3) + + 1283.0 * np.power(n, 4) + + 1371.0 * np.power(n, 5) + + 847.0 * np.power(n, 6) + + 138.0 * np.power(n, 7) + + 39.0 * np.power(n, 8) + ) + ) + / (np.power(n, 5) * np.power(1.0 + n, 5)) + + ( + 0.0013717421124828531 + * ( + 5184.0 + + 4752.0 * n + + 6336.0 * np.power(n, 2) + + 51804.0 * np.power(n, 3) + + 126914.0 * np.power(n, 4) + + 247433.0 * np.power(n, 5) + + 396657.0 * np.power(n, 6) + + 321746.0 * np.power(n, 7) + + 106856.0 * np.power(n, 8) + + 825.0 * np.power(n, 9) + + 165.0 * np.power(n, 10) + ) + ) + / (np.power(n, 5) * np.power(1.0 + n, 5)) + - ( + 0.5925925925925926 + * ( + -12.0 + - 10.0 * n + + 39.0 * np.power(n, 2) + + 77.0 * np.power(n, 3) + + 70.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + ) + * S1 + ) + / (np.power(n, 4) * np.power(1.0 + n, 4)) + + ( + 3.5555555555555554 + * (1.0 + 2.0 * n + 2.0 * np.power(n, 2)) + * np.power(S1, 2) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3)) + + (3.5555555555555554 * (1.0 + 2.0 * n + 2.0 * np.power(n, 2)) * S2) + / (np.power(n, 3) * np.power(1.0 + n, 3)) + - 2.3703703703703702 * np.power(S1, 3) * S2 + - ( + 0.4444444444444444 + * (14.0 + 15.0 * n + 15.0 * np.power(n, 2)) + * np.power(S2, 2) + ) + / (n * (1.0 + n)) + + 1.2020569031595942 + * ( + ( + 0.037037037037037035 + * ( + -432.0 + - 682.0 * n + - 3505.0 * np.power(n, 2) + - 4278.0 * np.power(n, 3) + - 2103.0 * np.power(n, 4) + + 648.0 * np.power(n, 5) + ) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + + ( + 0.14814814814814814 + * (108.0 + 593.0 * n + 593.0 * np.power(n, 2)) + * S1 + ) + / (n * (1.0 + n)) + - 16.0 * np.power(S1, 2) + + 16.0 * S2 + ) + - ( + 0.8888888888888888 + * ( + -8.0 + - 5.0 * n + - 15.0 * np.power(n, 2) + + 18.0 * np.power(n, 3) + + 16.0 * np.power(n, 4) + + 12.0 * np.power(n, 5) + ) + * S21 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + + 4.0 + * ( + (-0.5 * (2.0 + 3.0 * n + 3.0 * np.power(n, 2))) / (n * (1.0 + n)) + + 2.0 * S1 + ) + * (-15.338278920632018 - 4.0 * S211) + + 24.88888888888889 * S2111 + - 28.444444444444443 * S21m2 + + 21.333333333333332 * S221 + - 42.666666666666664 * S23 + + 28.444444444444443 * S2m3 + - ( + 0.09876543209876543 + * ( + -36.0 + + 144.0 * n + + 1151.0 * np.power(n, 2) + + 1573.0 * np.power(n, 3) + + 863.0 * np.power(n, 4) + + 27.0 * np.power(n, 5) + ) + * S3 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + - (0.2962962962962963 * (4.0 + 13.0 * n) * (9.0 + 13.0 * n) * S31) + / (n * (1.0 + n)) + - 28.444444444444443 * S311 + + (0.14814814814814814 * (78.0 + 443.0 * n + 443.0 * np.power(n, 2)) * S4) + / (n * (1.0 + n)) + + 28.444444444444443 * S41 + - 24.88888888888889 * S5 + + ( + ( + 0.3950617283950617 + * ( + 18.0 + - 3.0 * n + + 82.0 * np.power(n, 2) + + 266.0 * np.power(n, 3) + + 181.0 * np.power(n, 4) + ) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3)) + - ( + 0.7901234567901234 + * ( + 9.0 + + 9.0 * n + + 121.0 * np.power(n, 2) + + 224.0 * np.power(n, 3) + + 112.0 * np.power(n, 4) + ) + * S1 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + + (7.111111111111111 * np.power(S1, 2)) / (n * (1.0 + n)) + - 4.7407407407407405 * np.power(S1, 3) + + 23.703703703703702 * S2 + + 28.444444444444443 * S21 + - 9.481481481481481 * S3 + ) + * Sm2 + + S2 + * ( + ( + 0.04938271604938271 + * ( + 72.0 + + 63.0 * n + + 27.0 * np.power(n, 2) + + 940.0 * np.power(n, 3) + + 2487.0 * np.power(n, 4) + + 2469.0 * np.power(n, 5) + + 868.0 * np.power(n, 6) + ) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3)) + - 21.333333333333332 * S21 + + 18.37037037037037 * S3 + - 42.666666666666664 * Sm21 + ) + + ( + 0.7901234567901234 + * (18.0 - 39.0 * n + 112.0 * np.power(n, 2) + 112.0 * np.power(n, 3)) + * Sm21 + ) + / (np.power(n, 2) * (1.0 + n)) + + np.power(S1, 2) + * ( + ( + 0.4444444444444444 + * ( + 8.0 + + 7.0 * n + + 3.0 * np.power(n, 2) + + 10.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + + 3.0 * np.power(n, 5) + ) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3)) + + (3.5555555555555554 * S2) / (n * (1.0 + n)) + + 14.222222222222221 * S21 + - 8.88888888888889 * S3 + + 14.222222222222221 * Sm21 + ) + - (9.481481481481481 * (-3.0 + 10.0 * n + 10.0 * np.power(n, 2)) * Sm211) + / (n * (1.0 + n)) + + 113.77777777777777 * Sm2111 + + (2.3703703703703702 * (-3.0 + 10.0 * n + 10.0 * np.power(n, 2)) * Sm22) + / (n * (1.0 + n)) + + S1 + * ( + ( + -0.0054869684499314125 + * ( + 1620.0 + + 3456.0 * n + + 3240.0 * np.power(n, 2) + + 702.0 * np.power(n, 3) + + 7027.0 * np.power(n, 4) + + 39178.0 * np.power(n, 5) + + 62898.0 * np.power(n, 6) + + 43228.0 * np.power(n, 7) + + 10807.0 * np.power(n, 8) + ) + ) + / (np.power(n, 4) * np.power(1.0 + n, 4)) + - ( + 1.7777777777777777 + * (-1.0 + n) + * (-2.0 - 1.0 * n - 1.0 * np.power(n, 2) + 2.0 * np.power(n, 3)) + * S2 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + + 12.444444444444445 * np.power(S2, 2) + - (0.8888888888888888 * (16.0 + 9.0 * n + 9.0 * np.power(n, 2)) * S21) + / (n * (1.0 + n)) + + (8.88888888888889 * np.power(1.0 + 2.0 * n, 2) * S3) / (n * (1.0 + n)) + + 21.333333333333332 * S31 + - 23.11111111111111 * S4 + + ( + 4.7407407407407405 + * (-3.0 + 10.0 * n + 10.0 * np.power(n, 2)) + * Sm21 + ) + / (n * (1.0 + n)) + - 56.888888888888886 * Sm211 + + 14.222222222222221 * Sm22 + ) + - 28.444444444444443 * Sm221 + - 28.444444444444443 * Sm23 + + ( + ( + -0.3950617283950617 + * ( + 39.0 + + 169.0 * n + + 224.0 * np.power(n, 2) + + 112.0 * np.power(n, 3) + ) + ) + / (n * np.power(1.0 + n, 2)) + + (2.3703703703703702 * (3.0 + 10.0 * n + 10.0 * np.power(n, 2)) * S1) + / (n * (1.0 + n)) + - 7.111111111111111 * np.power(S1, 2) + - 7.111111111111111 * S2 + ) + * Sm3 + + ( + (2.3703703703703702 * (3.0 + 10.0 * n + 10.0 * np.power(n, 2))) + / (n * (1.0 + n)) + - 14.222222222222221 * S1 + ) + * Sm4 + - 14.222222222222221 * Sm5 + ) + + 0.8888888888888888 + * ( + ( + -0.19753086419753085 + * ( + 72.0 + + 132.0 * n + + 101.0 * np.power(n, 2) + + 485.0 * np.power(n, 3) + + 1283.0 * np.power(n, 4) + + 1371.0 * np.power(n, 5) + + 847.0 * np.power(n, 6) + + 138.0 * np.power(n, 7) + + 39.0 * np.power(n, 8) + ) + ) + / (np.power(n, 5) * np.power(1.0 + n, 5)) + + ( + 0.012345679012345678 + * ( + -144.0 + + 336.0 * n + + 1424.0 * np.power(n, 2) + + 3280.0 * np.power(n, 3) + - 2307.0 * np.power(n, 4) + - 32383.0 * np.power(n, 5) + - 79721.0 * np.power(n, 6) + - 95154.0 * np.power(n, 7) + - 72513.0 * np.power(n, 8) + - 31095.0 * np.power(n, 9) + - 6219.0 * np.power(n, 10) + ) + ) + / (np.power(n, 5) * np.power(1.0 + n, 5)) + + ( + 1.1851851851851851 + * ( + -12.0 + - 10.0 * n + + 39.0 * np.power(n, 2) + + 77.0 * np.power(n, 3) + + 70.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + ) + * S1 + ) + / (np.power(n, 4) * np.power(1.0 + n, 4)) + - ( + 7.111111111111111 + * (1.0 + 2.0 * n + 2.0 * np.power(n, 2)) + * np.power(S1, 2) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3)) + + 1.2020569031595942 + * ( + ( + 0.2222222222222222 + * ( + 48.0 + + 302.0 * n + + 767.0 * np.power(n, 2) + + 1122.0 * np.power(n, 3) + + 561.0 * np.power(n, 4) + ) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + - 134.22222222222223 * S1 + - 21.333333333333332 * S2 + ) + - (7.111111111111111 * (1.0 + 2.0 * n + 2.0 * np.power(n, 2)) * S2) + / (np.power(n, 3) * np.power(1.0 + n, 3)) + - ( + 0.5925925925925926 + * (-6.0 + 31.0 * n + 31.0 * np.power(n, 2)) + * np.power(S2, 2) + ) + / (n * (1.0 + n)) + + np.power(S1, 3) + * ( + (-0.5925925925925926 * (1.0 + 2.0 * n)) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + + 4.7407407407407405 * S2 + ) + + ( + 1.7777777777777777 + * ( + -4.0 + - 4.0 * n + + 3.0 * np.power(n, 2) + + 14.0 * np.power(n, 3) + + 7.0 * np.power(n, 4) + ) + * S21 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + + 4.0 + * ( + (-0.5 * (2.0 + 3.0 * n + 3.0 * np.power(n, 2))) / (n * (1.0 + n)) + + 2.0 * S1 + ) + * (17.688679036730377 + 2.6666666666666665 * S211) + + 56.888888888888886 * S21m2 + + 28.444444444444443 * S23 + - 56.888888888888886 * S2m3 + + ( + 0.09876543209876543 + * ( + -84.0 + + 492.0 * n + + 1853.0 * np.power(n, 2) + + 1954.0 * np.power(n, 3) + + 977.0 * np.power(n, 4) + ) + * S3 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + + (0.5925925925925926 * (30.0 + 89.0 * n + 89.0 * np.power(n, 2)) * S31) + / (n * (1.0 + n)) + + 28.444444444444443 * S311 + - (6.518518518518518 * (6.0 + 17.0 * n + 17.0 * np.power(n, 2)) * S4) + / (n * (1.0 + n)) + - 56.888888888888886 * S41 + + 56.888888888888886 * S5 + + ( + ( + -0.7901234567901234 + * ( + 18.0 + - 3.0 * n + + 82.0 * np.power(n, 2) + + 266.0 * np.power(n, 3) + + 181.0 * np.power(n, 4) + ) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3)) + + ( + 1.5802469135802468 + * ( + 9.0 + + 9.0 * n + + 121.0 * np.power(n, 2) + + 224.0 * np.power(n, 3) + + 112.0 * np.power(n, 4) + ) + * S1 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + - (14.222222222222221 * np.power(S1, 2)) / (n * (1.0 + n)) + + 9.481481481481481 * np.power(S1, 3) + - 47.407407407407405 * S2 + - 56.888888888888886 * S21 + + 18.962962962962962 * S3 + ) + * Sm2 + + np.power(S1, 2) + * ( + ( + -0.8888888888888888 + * ( + 2.0 + - 7.0 * n + - 9.0 * np.power(n, 2) + + 3.0 * np.power(n, 3) + + 7.0 * np.power(n, 4) + + 2.0 * np.power(n, 5) + ) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3)) + - (7.111111111111111 * S2) / (n * (1.0 + n)) + - 14.222222222222221 * S21 + + 21.333333333333332 * S3 + - 28.444444444444443 * Sm21 + ) + - ( + 1.5802469135802468 + * (18.0 - 39.0 * n + 112.0 * np.power(n, 2) + 112.0 * np.power(n, 3)) + * Sm21 + ) + / (np.power(n, 2) * (1.0 + n)) + + S2 + * ( + ( + -0.09876543209876543 + * ( + 162.0 + + 93.0 * n + + 31.0 * np.power(n, 2) + + 1595.0 * np.power(n, 3) + + 3433.0 * np.power(n, 4) + + 2718.0 * np.power(n, 5) + + 906.0 * np.power(n, 6) + ) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3)) + + 9.481481481481481 * S3 + + 85.33333333333333 * Sm21 + ) + + (18.962962962962962 * (-3.0 + 10.0 * n + 10.0 * np.power(n, 2)) * Sm211) + / (n * (1.0 + n)) + - 227.55555555555554 * Sm2111 + + S1 + * ( + ( + 0.024691358024691357 + * ( + -432.0 + - 552.0 * n + - 424.0 * np.power(n, 2) + - 5824.0 * np.power(n, 3) + - 3497.0 * np.power(n, 4) + + 23272.0 * np.power(n, 5) + + 43326.0 * np.power(n, 6) + + 28632.0 * np.power(n, 7) + + 7131.0 * np.power(n, 8) + ) + ) + / (np.power(n, 4) * np.power(1.0 + n, 4)) + + ( + 0.19753086419753085 + * ( + 45.0 + + 54.0 * n + + 484.0 * np.power(n, 2) + + 896.0 * np.power(n, 3) + + 448.0 * np.power(n, 4) + ) + * S2 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + - 7.111111111111111 * np.power(S2, 2) + + (14.222222222222221 * S21) / (n * (1.0 + n)) + - (2.3703703703703702 * (9.0 + 40.0 * n + 40.0 * np.power(n, 2)) * S3) + / (n * (1.0 + n)) + - 35.55555555555556 * S31 + + 78.22222222222223 * S4 + - (9.481481481481481 * (-3.0 + 10.0 * n + 10.0 * np.power(n, 2)) * Sm21) + / (n * (1.0 + n)) + + 113.77777777777777 * Sm211 + - 28.444444444444443 * Sm22 + ) + - (4.7407407407407405 * (-3.0 + 10.0 * n + 10.0 * np.power(n, 2)) * Sm22) + / (n * (1.0 + n)) + + 56.888888888888886 * Sm221 + + 56.888888888888886 * Sm23 + + ( + ( + 0.7901234567901234 + * ( + 39.0 + + 169.0 * n + + 224.0 * np.power(n, 2) + + 112.0 * np.power(n, 3) + ) + ) + / (n * np.power(1.0 + n, 2)) + - (4.7407407407407405 * (3.0 + 10.0 * n + 10.0 * np.power(n, 2)) * S1) + / (n * (1.0 + n)) + + 14.222222222222221 * np.power(S1, 2) + + 14.222222222222221 * S2 + ) + * Sm3 + + ( + (-4.7407407407407405 * (3.0 + 10.0 * n + 10.0 * np.power(n, 2))) + / (n * (1.0 + n)) + + 28.444444444444443 * S1 + ) + * Sm4 + + 28.444444444444443 * Sm5 + ) + ) diff --git a/src/eko/matching_conditions/n3lo/aqqPS.py b/src/eko/matching_conditions/n3lo/aqqPS.py index 9dbf4fbe0..e22773907 100644 --- a/src/eko/matching_conditions/n3lo/aqqPS.py +++ b/src/eko/matching_conditions/n3lo/aqqPS.py @@ -1,21 +1,92 @@ # -*- coding: utf-8 -*- -"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" +"""This module contains the |OME| aqqPS, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np -from ...anomalous_dimensions import harmonics -from . import g_functions as gf -zeta2 = harmonics.zeta2 -zeta3 = harmonics.zeta3 -zeta4 = harmonics.zeta4 -zeta5 = harmonics.zeta5 -li4half = 0.517479 -li5half = 0.508401 - - -@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) -def A_qqPS_3(n, sx, spx, nf, L): - S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] - Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] - return 0.0 +@nb.njit("c16(c16,c16[:],u4)", cache=True) +def A_qqPS_3(n, sx, nf): + S1, S2, S3 = sx[0], sx[1], sx[2] + return ( + 0.3333333333333333 + * nf + * ( + ( + -0.13168724279835392 + * ( + -864.0 + - 1008.0 * n + - 3408.0 * np.power(n, 2) + - 11704.0 * np.power(n, 3) + + 34274.0 * np.power(n, 4) + + 204541.0 * np.power(n, 5) + + 423970.0 * np.power(n, 6) + + 532664.0 * np.power(n, 7) + + 492456.0 * np.power(n, 8) + + 354532.0 * np.power(n, 9) + + 187681.0 * np.power(n, 10) + + 66389.0 * np.power(n, 11) + + 13931.0 * np.power(n, 12) + + 1330.0 * np.power(n, 13) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + + ( + 0.3950617283950617 + * ( + 288.0 + - 96.0 * n + - 928.0 * np.power(n, 2) + + 3272.0 * np.power(n, 3) + + 12030.0 * np.power(n, 4) + + 15396.0 * np.power(n, 5) + + 14606.0 * np.power(n, 6) + + 11454.0 * np.power(n, 7) + + 5937.0 * np.power(n, 8) + + 1744.0 * np.power(n, 9) + + 233.0 * np.power(n, 10) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + ( + -96.0 + - 16.0 * n + + 404.0 * np.power(n, 2) + + 452.0 * np.power(n, 3) + + 521.0 * np.power(n, 4) + + 430.0 * np.power(n, 5) + + 185.0 * np.power(n, 6) + + 40.0 * np.power(n, 7) + ) + * (-0.5925925925925926 * np.power(S1, 2) - 0.5925925925925926 * S2) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + 34.19184080098401 + + 2.962962962962963 * np.power(S1, 3) + + 8.88888888888889 * S1 * S2 + + 5.925925925925926 * S3 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) From d8f7102950213968a9c6a6c2917379bca9af3fd4 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Wed, 29 Sep 2021 15:10:43 +0200 Subject: [PATCH 38/71] adding init and small fixes --- src/eko/matching_conditions/n3lo/__init__.py | 40 +++++++++++-------- .../matching_conditions/n3lo/cs_functions.py | 7 +++- .../matching_conditions/n3lo/s_functions.py | 4 +- 3 files changed, 31 insertions(+), 20 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/__init__.py b/src/eko/matching_conditions/n3lo/__init__.py index 7c6670c5b..a2c8e9739 100644 --- a/src/eko/matching_conditions/n3lo/__init__.py +++ b/src/eko/matching_conditions/n3lo/__init__.py @@ -2,7 +2,7 @@ """ This module defines the matching conditions for the N3LO |VFNS| evolution. """ -import numba as nb +# import numba as nb import numpy as np from .agg import A_gg_3 @@ -10,22 +10,25 @@ from .aqg import A_qg_3 from .aqqPS import A_qqPS_3 from .aqqNS import A_qqNS_3 -from .aHg import A_Qg_3 -from .aHq import A_Qq_3 +from .aHg import A_Hg_3 +from .aHq import A_Hq_3 -@nb.njit("c16[:,:](c16,c16[:],u4,f8)", cache=True) -def A_singlet_3(n, sx, nf, L): - spx = sx[-5:] - A_hq = A_Qq_3(n, sx, spx, nf, L) - A_hg = A_Qg_3(n, sx, spx, nf, L) +# @nb.njit("c16[:,:](c16,c16[:],u4)", cache=True) +def A_singlet_3(n, sx_all, nf): + sx = sx_all[:5] + smx = sx_all[5:10] + s3x = sx_all[10:14] + s4x = sx_all[14:] + A_hq = A_Hq_3(n, sx, smx, s3x, s4x, nf) + A_hg = A_Hg_3(n, sx, smx, s3x, s4x, nf) - A_gq = A_gq_3(n, sx, spx, nf, L) - A_gg = A_gg_3(n, sx, spx, nf, L) + A_gq = A_gq_3(n, sx, smx, s3x, s4x, nf) + A_gg = A_gg_3(n, sx, smx, s3x, s4x, nf) - A_qq_ps = A_qqPS_3(n, sx, spx, nf, L) - A_qq_ns = A_qqNS_3(n, sx, spx, nf, L) - A_qg = A_qg_3(n, sx, spx, nf, L) + A_qq_ps = A_qqPS_3(n, sx, nf) + A_qq_ns = A_qqNS_3(n, sx, smx, s3x, s4x, nf) + A_qg = A_qg_3(n, sx, smx, s3x, s4x, nf) A_S_3 = np.array( [[A_gg, A_gq, 0.0], [A_qg, A_qq_ps + A_qq_ns, 0.0], [A_hg, A_hq, 0.0]], @@ -34,8 +37,11 @@ def A_singlet_3(n, sx, nf, L): return A_S_3 -@nb.njit("c16[:,:](c16,c16[:],u4,f8)", cache=True) -def A_ns_3(n, sx, nf, L): - spx = sx[-5:] - A_qq = A_qqNS_3(n, sx, spx, nf, L) +# @nb.njit("c16[:,:](c16,c16[:],u4)", cache=True) +def A_ns_3(n, sx_all, nf): + sx = sx_all[:5] + smx = sx_all[5:10] + s3x = sx_all[10:14] + s4x = sx_all[14:] + A_qq = A_qqNS_3(n, sx, smx, s3x, s4x, nf) return np.array([[A_qq, 0.0], [0 + 0j, 0 + 0j]], np.complex_) diff --git a/src/eko/matching_conditions/n3lo/cs_functions.py b/src/eko/matching_conditions/n3lo/cs_functions.py index cb96293dd..e254eee4b 100644 --- a/src/eko/matching_conditions/n3lo/cs_functions.py +++ b/src/eko/matching_conditions/n3lo/cs_functions.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- """This module contains some approximations for generalized harmonics sum""" -import numba as nb +#import numba as nb import numpy as np import mpmath as mp from ...anomalous_dimensions.harmonics import zeta2, zeta3 @@ -12,6 +12,11 @@ def S111l211(H24): return complex(H24) +# @nb.njit("c16(c16)", cache=True) +def S12l21(H25): + return complex(-2.0 * H25) + + # @nb.njit("c16(c16,c16)", cache=True) def S1111l20511(n, S1): return complex( diff --git a/src/eko/matching_conditions/n3lo/s_functions.py b/src/eko/matching_conditions/n3lo/s_functions.py index 33e6d1970..67a5202d6 100644 --- a/src/eko/matching_conditions/n3lo/s_functions.py +++ b/src/eko/matching_conditions/n3lo/s_functions.py @@ -20,9 +20,9 @@ log2 = np.log(2) # @nb.njit("c16(c16,c16)", cache=True) -def binomial(x,y): +def binomial(x, y): """Binomial coefficient for complex numbers""" - return sp.gamma(x+1)/(sp.gamma(y+1) * sp.gamma(x-y+1)) + return sp.gamma(x + 1) / (sp.gamma(y + 1) * sp.gamma(x - y + 1)) @nb.njit("c16(c16)", cache=True) From 21a6d2267c980db4c0122f3a63b1e887640eb0be Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Wed, 29 Sep 2021 15:12:19 +0200 Subject: [PATCH 39/71] test and allow N3LO in operator matrix element --- src/eko/evolution_operator/grid.py | 2 +- .../operator_matrix_element.py | 78 +++++++++-- tests/test_matching_n3lo.py | 127 ++++++++++++++++++ tests/test_ome.py | 77 +++++++++-- 4 files changed, 262 insertions(+), 22 deletions(-) create mode 100644 tests/test_matching_n3lo.py diff --git a/src/eko/evolution_operator/grid.py b/src/eko/evolution_operator/grid.py index b1c467a2d..a63f43fc1 100644 --- a/src/eko/evolution_operator/grid.py +++ b/src/eko/evolution_operator/grid.py @@ -182,7 +182,7 @@ def get_threshold_operators(self, path): kthr = self.managers["thresholds_config"].thresholds_ratios[ seg.nf - shift ] - ome.compute(seg.q2_to, np.log(kthr)) + ome.compute(seg.q2_to, seg.nf - shift + 3, np.log(kthr)) self._matching_operators[seg.q2_to] = ome.ome_members return thr_ops diff --git a/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index 06906e614..f61874376 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -15,13 +15,46 @@ from ..anomalous_dimensions import harmonics from ..basis_rotation import singlet_labels from ..member import OpMember -from . import nlo, nnlo +from . import nlo, nnlo, n3lo +from .n3lo import s_functions logger = logging.getLogger(__name__) - -@nb.njit("c16[:,:,:](u1,c16,c16[:],f8)", cache=True) -def A_singlet(order, n, sx, L): +@nb.njit("c16[:](c16)", cache=True) +def get_smx(n): + """Get the S-minus cache""" + return np.array([ + s_functions.harmonic_Sm1(n), + s_functions.harmonic_Sm2(n), + s_functions.harmonic_Sm3(n), + s_functions.harmonic_Sm4(n), + s_functions.harmonic_Sm5(n), + ]) + +@nb.njit("c16[:](c16,c16[:],c16[:])", cache=True) +def get_s3x(n, sx, smx): + """Get the S-w3 cache""" + return np.array([ + s_functions.harmonic_S21(n, sx[0], sx[1]), + s_functions.harmonic_S2m1(n, sx[1], smx[0], smx[1]), + s_functions.harmonic_Sm21(n, smx[0]), + s_functions.harmonic_Sm2m1(n, sx[0], sx[1], smx[1]), + ]) + +@nb.njit("c16[:](c16,c16[:],c16[:])", cache=True) +def get_s4x(n, sx, smx): + """Get the S-w4 cache""" + Sm31 = s_functions.harmonic_Sm31(n, smx[0], smx[1]) + return np.array([ + s_functions.harmonic_S31(n, sx[1], sx[3]), + s_functions.harmonic_S211(n, sx[0], sx[1], sx[2]), + s_functions.harmonic_Sm22(n, Sm31), + s_functions.harmonic_Sm211(n, smx[0] ), + s_functions.harmonic_Sm31(n, smx[0], smx[1]), + ]) + +# @nb.njit("c16[:,:,:](u1,c16,c16[:],u4,f8)", cache=True) +def A_singlet(order, n, sx, nf, L): r""" Computes the tower of the singlet |OME|. @@ -55,11 +88,13 @@ def A_singlet(order, n, sx, L): A_singlet[0] = nlo.A_singlet_1(n, sx, L) if order >= 2: A_singlet[1] = nnlo.A_singlet_2(n, sx, L) + if order >= 3: + A_singlet[2] = n3lo.A_singlet_3(n, sx, nf) return A_singlet -@nb.njit("c16[:,:,:](u1,c16,c16[:],f8)", cache=True) -def A_non_singlet(order, n, sx, L): +# @nb.njit("c16[:,:,:](u1,c16,c16[:],u4,f8)", cache=True) +def A_non_singlet(order, n, sx, nf, L): r""" Computes the tower of the non-singlet |OME| @@ -91,10 +126,12 @@ def A_non_singlet(order, n, sx, L): A_ns[0] = nlo.A_ns_1(n, sx, L) if order >= 2: A_ns[1] = nnlo.A_ns_2(n, sx, L) + if order >= 3: + A_ns[2] = n3lo.A_ns_3(n, sx, nf) return A_ns -@nb.njit("c16[:,:](c16[:,:,:],u4,f8,string)", cache=True) +# @nb.njit("c16[:,:](c16[:,:,:],u4,f8,string)", cache=True) def build_ome(A, order, a_s, backward_method): r""" Construct the matching expansion in :math:`a_s` with the appropriate method. @@ -124,20 +161,26 @@ def build_ome(A, order, a_s, backward_method): ome += a_s ** 2 * ( -A[1] + np.ascontiguousarray(A[0]) @ np.ascontiguousarray(A[0]) ) + if order >= 3: + ome += a_s ** 3 * ( + -A[2] + 2 * np.ascontiguousarray(A[0]) @ np.ascontiguousarray(A[1]) - np.ascontiguousarray(A[0]) @ np.ascontiguousarray(A[0]) @ np.ascontiguousarray(A[0]) + ) else: # forward or exact inverse if order >= 1: ome += a_s * A[0] if order >= 2: ome += a_s ** 2 * A[1] + if order >= 3: + ome += a_s ** 3 * A[2] # need inverse exact ? so add the missing pieces if backward_method == "exact": ome = np.linalg.inv(ome) return ome -@nb.njit("f8(f8,u1,string,b1,f8,f8[:,:],f8,f8,string)", cache=True) -def quad_ker(u, order, mode, is_log, logx, areas, a_s, L, backward_method): +# @nb.njit("f8(f8,u1,string,b1,f8,f8[:,:],f8,u4,f8,string)", cache=True) +def quad_ker(u, order, mode, is_log, logx, areas, a_s, nf, L, backward_method): """ Raw kernel inside quad @@ -184,12 +227,18 @@ def quad_ker(u, order, mode, is_log, logx, areas, a_s, L, backward_method): sx = np.array([harmonics.harmonic_S1(n), harmonics.harmonic_S2(n)]) if order >= 2: sx = np.append(sx, harmonics.harmonic_S3(n)) - + if order >= 3: + sx = np.append(sx, harmonics.harmonic_S4(n)) + sx = np.append(sx, harmonics.harmonic_S5(n)) + smx = get_smx(n) + sx = np.append(sx, smx) + sx = np.append(sx, get_s3x(n, sx,smx)) + sx = np.append(sx, get_s4x(n, sx,smx)) # compute the ome if is_singlet: - A = A_singlet(order, n, sx, L) + A = A_singlet(order, n, sx, nf, L) else: - A = A_non_singlet(order, n, sx, L) + A = A_non_singlet(order, n, sx, nf, L) # check PDF is active if is_log: @@ -275,7 +324,7 @@ def labels(self): # labels.extend(["S_qH"]) return labels - def compute(self, q2, L): + def compute(self, q2, nf, L): """ compute the actual operators (i.e. run the integrations) @@ -283,6 +332,8 @@ def compute(self, q2, L): ---------- q2: float threshold scale + nf: int + mumber of active flavor below threshold L: float log of K threshold squared """ @@ -324,6 +375,7 @@ def compute(self, q2, L): logx, bf.areas_representation, a_s, + nf, L, self.backward_method, ), diff --git a/tests/test_matching_n3lo.py b/tests/test_matching_n3lo.py new file mode 100644 index 000000000..cc85f23f9 --- /dev/null +++ b/tests/test_matching_n3lo.py @@ -0,0 +1,127 @@ +# -*- coding: utf-8 -*- +# Test NNLO OME + +import numpy as np + +from eko.anomalous_dimensions import harmonics +from eko.matching_conditions.n3lo import A_ns_3, A_singlet_3, A_qqNS_3, s_functions +from eko.matching_conditions import n3lo + + +def get_sx(N): + """Collect the S-cache""" + sx = np.array( + [ + harmonics.harmonic_S1(N), + harmonics.harmonic_S2(N), + harmonics.harmonic_S3(N), + harmonics.harmonic_S4(N), + harmonics.harmonic_S5(N), + ] + ) + return sx + + +def get_smx(N): + """Collect the Sminus-cache""" + smx = np.array( + [ + s_functions.harmonic_Sm1(N), + s_functions.harmonic_Sm2(N), + s_functions.harmonic_Sm3(N), + s_functions.harmonic_Sm4(N), + s_functions.harmonic_Sm5(N), + ] + ) + return smx + + +def get_s3x(N, sx, smx): + """Collect the Sminus-cache""" + s3x = np.array( + [ + s_functions.harmonic_S21(N, sx[0], sx[1]), + s_functions.harmonic_S2m1(N, sx[1], smx[0], smx[1]), + s_functions.harmonic_Sm21(N, smx[0]), + s_functions.harmonic_Sm2m1(N, sx[0], sx[1], smx[1]), + ] + ) + return s3x + + +def get_s4x(N, sx, smx): + """Collect the Sminus-cache""" + Sm31 = s_functions.harmonic_Sm31(N, smx[0], smx[1]) + s4x = np.array( + [ + s_functions.harmonic_S31(N, sx[1], sx[3]), + s_functions.harmonic_S211(N, sx[0], sx[1], sx[2]), + s_functions.harmonic_Sm22(N, Sm31), + s_functions.harmonic_Sm211(N, smx[0]), + Sm31, + ] + ) + return s4x + + +def test_A_2(): + nf = 3 + N = 1 + sx = get_sx(N) + smx = get_smx(N) + s3x = get_s3x(N, sx, smx) + s4x = get_s4x(N, sx, smx) + + aNSqq3 = A_qqNS_3(N, sx, smx, s3x, s4x, nf) + # quark number conservation + # the accuracy of this test depends directly on the precision of the + # F functions, thus is dominated by F19,F20,F21 accuracy are the worst ones + # If needed, these Fs can be improved. + np.testing.assert_allclose(aNSqq3, 0.0, atol=5e-3) + + N = complex(2.0) + sx = get_sx(N) + smx = get_smx(N) + s3x = get_s3x(N, sx, smx) + s4x = get_s4x(N, sx, smx) + # reference value comes form Mathemtica, gg is not fullycomplete + # thus the reference value is not 0.0 + # Here the acuracy of this test depends on the approximation of AggTF2 + np.testing.assert_allclose( + n3lo.A_gg_3(N, sx, smx, s3x, s4x, nf) + + n3lo.A_qg_3(N, sx, smx, s3x, s4x, nf) + + n3lo.A_Hg_3(N, sx, smx, s3x, s4x, nf), + 145.148, + rtol=4e-2, + ) + + # here you get division by 0 as in Mathematica + # np.testing.assert_allclose( + # n3lo.A_gq_3(N, sx, smx, s3x, s4x, nf) + # + n3lo.A_qqNS_3(N, sx, smx, s3x, s4x, nf) + # + n3lo.A_qqPS_3(N, sx, nf) + # + n3lo.A_Hq_3(N, sx, smx, s3x, s4x, nf), + # 0.0, + # atol=2e-6, + # ) + + # here you get division by 0 as in Mathematica + # sx_all = get_sx(N) + # sx_all = np.append(sx_all, get_smx(N)) + # sx_all = np.append(sx_all, get_s3x(N, get_sx(N),get_smx(N))) + # sx_all = np.append(sx_all, get_s4x(N, get_sx(N),get_smx(N))) + # aS3 = A_singlet_3(N, sx_all, nf) + # gluon momentum conservation + # np.testing.assert_allclose(aS3[0, 0] + aS3[1, 0] + aS3[2, 0], 0.0, atol=2e-6) + # quark momentum conservation + # np.testing.assert_allclose(aS3[0, 1] + aS3[1, 1] + aS3[2, 1], 0.0, atol=1e-11) + + N = 3 + 2j + sx_all = np.random.rand(19) + 1j * np.random.rand(19) + aS3 = A_singlet_3(N, sx_all, nf) + aNS3 = A_ns_3(N, sx_all, nf) + assert aNS3.shape == (2, 2) + assert aS3.shape == (3, 3) + + np.testing.assert_allclose(aS3[:, 2], np.zeros(3)) + np.testing.assert_allclose(aNS3[1, 1], 0) diff --git a/tests/test_ome.py b/tests/test_ome.py index 4a33dbe02..e37f2d3ee 100644 --- a/tests/test_ome.py +++ b/tests/test_ome.py @@ -3,6 +3,13 @@ import numpy as np from eko import interpolation, mellin +from eko.anomalous_dimensions.harmonics import ( + harmonic_S1, + harmonic_S2, + harmonic_S3, + harmonic_S4, + harmonic_S5, +) from eko.basis_rotation import singlet_labels from eko.evolution_operator.grid import OperatorGrid from eko.interpolation import InterpolatorDispatcher @@ -12,9 +19,54 @@ OperatorMatrixElement, build_ome, quad_ker, + get_s3x, + get_s4x, + get_smx, ) from eko.strong_coupling import StrongCoupling from eko.thresholds import ThresholdsAtlas +from eko.matching_conditions.n3lo import s_functions as sf + + +def test_HarmonicsCache(): + N = np.random.rand() + 1.0j * np.random.rand() + Sm1 = sf.harmonic_Sm1(N) + Sm2 = sf.harmonic_Sm2(N) + S1 = harmonic_S1(N) + S2 = harmonic_S2(N) + S3 = harmonic_S3(N) + S4 = harmonic_S4(N) + sx = np.array([S1, S2, S3, S4, harmonic_S5(N)]) + smx_test = np.array( + [ + Sm1, + Sm2, + sf.harmonic_Sm3(N), + sf.harmonic_Sm4(N), + sf.harmonic_Sm5(N), + ] + ) + np.testing.assert_allclose(get_smx(N), smx_test) + s3x_test = np.array( + [ + sf.harmonic_S21(N, S1, S2), + sf.harmonic_S2m1(N, S2, Sm1, Sm2), + sf.harmonic_Sm21(N, Sm1), + sf.harmonic_Sm2m1(N, S1, S2, Sm2), + ] + ) + np.testing.assert_allclose(get_s3x(N, sx, smx_test), s3x_test) + Sm31 = sf.harmonic_Sm31(N, Sm1, Sm2) + s4x_test = np.array( + [ + sf.harmonic_S31(N, S2, S4), + sf.harmonic_S211(N, S1, S2, S3), + sf.harmonic_Sm22(N, Sm31), + sf.harmonic_Sm211(N, Sm1), + Sm31, + ] + ) + np.testing.assert_allclose(get_s4x(N, sx, smx_test), s4x_test) def test_build_ome_as(): @@ -22,10 +74,13 @@ def test_build_ome_as(): N = 2 L = 0.0 a_s = 0.0 - sx = np.zeros(3, np.complex_) - for o in [0, 1, 2]: - aNS = A_non_singlet(o, N, sx, L) - aS = A_singlet(o, N, sx, L) + sx = np.random.rand(19) + 1j * np.random.rand(19) + nf = 3 + for o in [0, 1, 2, 3]: + if o == 3: + N = complex(2.123) + aNS = A_non_singlet(o, N, sx, nf, L) + aS = A_singlet(o, N, sx, nf, L) for a in [aNS, aS]: for method in ["", "expanded", "exact"]: @@ -44,9 +99,9 @@ def test_build_ome_nlo(): L = 0.0 a_s = 20 sx = np.array([1, 1, 1], np.complex_) - - aNSi = A_non_singlet(1, N, sx, L) - aSi = A_singlet(1, N, sx, L) + nf = 4 + aNSi = A_non_singlet(1, N, sx, nf, L) + aSi = A_singlet(1, N, sx, nf, L) for a in [aNSi, aSi]: for method in ["", "expanded", "exact"]: dim = len(a[0]) @@ -94,6 +149,7 @@ def test_quad_ker(monkeypatch): areas=np.zeros(3), backward_method=None, a_s=0.0, + nf=3, L=0.0, ) np.testing.assert_allclose(res_ns, 1.0) @@ -106,6 +162,7 @@ def test_quad_ker(monkeypatch): areas=np.zeros(3), backward_method=None, a_s=0.0, + nf=3, L=0.0, ) np.testing.assert_allclose(res_s, 1.0) @@ -118,6 +175,7 @@ def test_quad_ker(monkeypatch): areas=np.zeros(3), backward_method=None, a_s=0.0, + nf=3, L=0.0, ) np.testing.assert_allclose(res_s, 0.0) @@ -134,6 +192,7 @@ def test_quad_ker(monkeypatch): areas=np.zeros(3), backward_method="expanded", a_s=0.0, + nf=3, L=0.0, ) if label[-1] == label[-2]: @@ -164,6 +223,7 @@ def test_quad_ker(monkeypatch): areas=np.zeros(3), backward_method="exact", a_s=0.0, + nf=3, L=0.0, ) if label[-1] == label[-2]: @@ -181,6 +241,7 @@ def test_quad_ker(monkeypatch): areas=np.array([0.01, 0.1, 1.0]), backward_method=None, a_s=0.0, + nf=3, L=0.0, ) np.testing.assert_allclose(res_ns, 0.0) @@ -265,7 +326,7 @@ def test_compute(self): InterpolatorDispatcher.from_dict(operators_card), ) o = OperatorMatrixElement(g.config, g.managers, is_backward=False) - o.compute(self.theory_card["mb"] ** 2, L=0) + o.compute(self.theory_card["mb"] ** 2, nf=4, L=0) dim = o.ome_members["NS_qq"].value.shape for idx in ["S", "NS"]: From 668d6500dfa9d771d296628b563bfe8bcf5c40eb Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 30 Sep 2021 12:36:54 +0200 Subject: [PATCH 40/71] pylint fixes --- setup.py | 1 + src/eko/matching_conditions/n3lo/aHg.py | 1 + src/eko/matching_conditions/n3lo/aggTF2.py | 14 +++++++++----- src/eko/matching_conditions/n3lo/agq.py | 2 +- src/eko/matching_conditions/n3lo/aqqNS.py | 2 +- src/eko/matching_conditions/n3lo/cs_functions.py | 4 ++-- src/eko/matching_conditions/n3lo/f_functions.py | 1 + src/eko/matching_conditions/n3lo/s_functions.py | 6 ++++-- 8 files changed, 20 insertions(+), 11 deletions(-) diff --git a/setup.py b/setup.py index ed72a0f39..8f08bd170 100644 --- a/setup.py +++ b/setup.py @@ -53,6 +53,7 @@ def setup_package(): "numba", "pyyaml", "lz4", + "mpmath" ], python_requires=">=3.7", ) diff --git a/src/eko/matching_conditions/n3lo/aHg.py b/src/eko/matching_conditions/n3lo/aHg.py index 167f75a7e..504d54c4f 100644 --- a/src/eko/matching_conditions/n3lo/aHg.py +++ b/src/eko/matching_conditions/n3lo/aHg.py @@ -1,4 +1,5 @@ # -*- coding: utf-8 -*- +# pylint: disable=too-many-lines """This module contains the |OME| aHg, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np diff --git a/src/eko/matching_conditions/n3lo/aggTF2.py b/src/eko/matching_conditions/n3lo/aggTF2.py index 1e38dce94..acef7ac8f 100644 --- a/src/eko/matching_conditions/n3lo/aggTF2.py +++ b/src/eko/matching_conditions/n3lo/aggTF2.py @@ -1,5 +1,8 @@ # -*- coding: utf-8 -*- -"""This module contains the |OME| aggTF2, the experssions are taken from :cite:`Bierenbaum_2009`""" +""" +This module contains the inclomplete |OME| aggTF2, +the experssions are taken from :cite:`Bierenbaum_2009` +""" import numpy as np from .s_functions import binomial @@ -8,6 +11,7 @@ def A_ggTF2_3(n, sx, s3x): S1, S2, S3 = sx[0], sx[1], sx[2] S21 = s3x[0] + binfact = binomial(2 * n, n) / 4 ** n return 0.3333333333333333 * ( ( 0.1335618781288438 @@ -137,7 +141,7 @@ def A_ggTF2_3(n, sx, s3x): / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ( 2.80479944070572 - * np.power(4.0, 2.0 - 1.0 * n) + * np.power(4.0, 2) * ( -80.0 - 104.0 * n @@ -147,7 +151,7 @@ def A_ggTF2_3(n, sx, s3x): + 9.0 * np.power(n, 5) + 9.0 * np.power(n, 6) ) - * binomial(2.0 * n, n) + * binfact ) / ( (-1.0 + n) @@ -276,7 +280,7 @@ def A_ggTF2_3(n, sx, s3x): / ((-1.0 + n) * n * (1.0 + n)) + ( 0.18698662938038133 - * np.power(4.0, 1.0 - 1.0 * n) + * np.power(4.0, 1) * ( 996.0 + 712.0 * n @@ -288,7 +292,7 @@ def A_ggTF2_3(n, sx, s3x): + 539.0 * np.power(n, 7) + 100.0 * np.power(n, 8) ) - * binomial(2.0 * n, n) + * binfact ) / ( (-1.0 + n) diff --git a/src/eko/matching_conditions/n3lo/agq.py b/src/eko/matching_conditions/n3lo/agq.py index 07e473409..d89da48bc 100644 --- a/src/eko/matching_conditions/n3lo/agq.py +++ b/src/eko/matching_conditions/n3lo/agq.py @@ -5,7 +5,7 @@ @nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) -def A_gq_3(n, sx, smx, s3x, s4x, nf): +def A_gq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] Sm1, Sm2, Sm3, Sm4 = smx[0], smx[1], smx[2], smx[3] S21, S2m1, Sm21, Sm2m1 = s3x[0], s3x[1], s3x[2], s3x[3] diff --git a/src/eko/matching_conditions/n3lo/aqqNS.py b/src/eko/matching_conditions/n3lo/aqqNS.py index d3387dbe4..325fc0038 100644 --- a/src/eko/matching_conditions/n3lo/aqqNS.py +++ b/src/eko/matching_conditions/n3lo/aqqNS.py @@ -7,7 +7,7 @@ @nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) -def A_qqNS_3(n, sx, smx, s3x, s4x, nf): +def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] Sm1, Sm2, Sm3, Sm4, Sm5 = smx[0], smx[1], smx[2], smx[3], smx[4] S21, S2m1, Sm21 = s3x[0], s3x[1], s3x[2] diff --git a/src/eko/matching_conditions/n3lo/cs_functions.py b/src/eko/matching_conditions/n3lo/cs_functions.py index e254eee4b..d293b465a 100644 --- a/src/eko/matching_conditions/n3lo/cs_functions.py +++ b/src/eko/matching_conditions/n3lo/cs_functions.py @@ -8,8 +8,8 @@ ln2 = np.log(2) # @nb.njit("c16(c16)", cache=True) -def S111l211(H24): - return complex(H24) +def S111l211(H22,H24): + return complex(H24 + H22) # @nb.njit("c16(c16)", cache=True) diff --git a/src/eko/matching_conditions/n3lo/f_functions.py b/src/eko/matching_conditions/n3lo/f_functions.py index 0c253be04..6f61fe988 100644 --- a/src/eko/matching_conditions/n3lo/f_functions.py +++ b/src/eko/matching_conditions/n3lo/f_functions.py @@ -1,4 +1,5 @@ # -*- coding: utf-8 -*- +# pylint: disable=too-many-lines """ This module contains some Mellin transfomations for 5th order harmonics sum. Notation refers to :cite:`Bl_mlein_2009` diff --git a/src/eko/matching_conditions/n3lo/s_functions.py b/src/eko/matching_conditions/n3lo/s_functions.py index 67a5202d6..43cd82f81 100644 --- a/src/eko/matching_conditions/n3lo/s_functions.py +++ b/src/eko/matching_conditions/n3lo/s_functions.py @@ -5,7 +5,7 @@ """ import numpy as np import numba as nb -from scipy import special as sp +import mpmath as mp from eko.anomalous_dimensions import harmonics from . import g_functions as gf @@ -22,7 +22,9 @@ # @nb.njit("c16(c16,c16)", cache=True) def binomial(x, y): """Binomial coefficient for complex numbers""" - return sp.gamma(x + 1) / (sp.gamma(y + 1) * sp.gamma(x - y + 1)) + # return sp.gamma(x + 1) / (sp.gamma(y + 1) * sp.gamma(x - y + 1)) + # more accurate for large numbers. + return complex(1/((x +1) * mp.beta(x-y+1,y+1))) @nb.njit("c16(c16)", cache=True) From 61d1378da5a236f3814a2cd773aeda4893901b5d Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 30 Sep 2021 12:38:57 +0200 Subject: [PATCH 41/71] more OME n3lo tests --- tests/test_ad_harmonics.py | 8 ++- tests/test_g_functions.py | 1 - tests/test_matching_n3lo.py | 106 +++++++++++++++++++++++++++++++++++- tests/test_matching_nnlo.py | 2 +- tests/test_s_functions.py | 9 ++- 5 files changed, 119 insertions(+), 7 deletions(-) diff --git a/tests/test_ad_harmonics.py b/tests/test_ad_harmonics.py index 2ec136b41..b33ccd64c 100644 --- a/tests/test_ad_harmonics.py +++ b/tests/test_ad_harmonics.py @@ -86,7 +86,13 @@ def test_harmonic_Sx(): def sx(n, m): return np.sum([1 / k ** m for k in range(1, n + 1)]) - ls = [harmonics.harmonic_S1, harmonics.harmonic_S2, harmonics.harmonic_S3, harmonics.harmonic_S4, harmonics.harmonic_S5] + ls = [ + harmonics.harmonic_S1, + harmonics.harmonic_S2, + harmonics.harmonic_S3, + harmonics.harmonic_S4, + harmonics.harmonic_S5, + ] for k in range(1, 5 + 1): for n in range(1, 4 + 1): np.testing.assert_almost_equal(ls[k - 1](n), sx(n, k)) diff --git a/tests/test_g_functions.py b/tests/test_g_functions.py index 33a2c9f47..d0f7f0e7d 100644 --- a/tests/test_g_functions.py +++ b/tests/test_g_functions.py @@ -4,7 +4,6 @@ import numpy as np from eko.anomalous_dimensions import harmonics -import eko.matching_conditions.n3lo.g_functions as gf import eko.matching_conditions.n3lo.s_functions as sf zeta3 = harmonics.zeta3 diff --git a/tests/test_matching_n3lo.py b/tests/test_matching_n3lo.py index cc85f23f9..189282da0 100644 --- a/tests/test_matching_n3lo.py +++ b/tests/test_matching_n3lo.py @@ -66,7 +66,7 @@ def get_s4x(N, sx, smx): def test_A_2(): nf = 3 - N = 1 + N = 1.0 sx = get_sx(N) smx = get_smx(N) s3x = get_s3x(N, sx, smx) @@ -79,7 +79,7 @@ def test_A_2(): # If needed, these Fs can be improved. np.testing.assert_allclose(aNSqq3, 0.0, atol=5e-3) - N = complex(2.0) + N = 2.0 sx = get_sx(N) smx = get_smx(N) s3x = get_s3x(N, sx, smx) @@ -92,7 +92,7 @@ def test_A_2(): + n3lo.A_qg_3(N, sx, smx, s3x, s4x, nf) + n3lo.A_Hg_3(N, sx, smx, s3x, s4x, nf), 145.148, - rtol=4e-2, + rtol=32e-3, ) # here you get division by 0 as in Mathematica @@ -125,3 +125,103 @@ def test_A_2(): np.testing.assert_allclose(aS3[:, 2], np.zeros(3)) np.testing.assert_allclose(aNS3[1, 1], 0) + + +def test_Bluemlein_2(): + # Test against Blumlein OME implementation :cite:`Bierenbaum_2009`. + # For singlet OME only even moments are available in that code. + # Note there is a minus sign in the definition of L. + + ref_val_gg = { + 0: [-440.104, -1377.49, -1683.31, -2006.18, -3293.81], + } + # Mathematica not able to evaluate for N=100 + ref_val_ggTF2 = { + 0: [-33.4281, -187.903, -239.019, -294.571], + } + # diverging for N=2 + ref_val_gq = { + 0: [0, 22.7356, 16.4025, 10.5142, 0.98988], + } + ref_val_Hg = { + 0: [461.219, 682.728, 676.549, 626.857, 294.313], + } + ref_val_Hgstfac = { + 0: [109.766, 64.7224, 25.1745, -11.5071, -37.9846], + } + ref_val_Hq = { + 0: [15.6809, 1.82795, 1.01716, 0.595205, 0.0065763], + } + ref_val_qg = { + 0: [47.695, 44.8523, 32.6934, 19.8899, 0.397559], + } + ref_val_qqNS = { + 0: [-37.0244, -40.1562, -36.0358, -28.3506, 6.83759], + } + ref_val_qqPS = { + 0: [-8.65731, -0.766936, -0.0365199, 0.147675, 0.0155598], + } + nf = 3 + for i, N in enumerate([4.0, 6.0, 10.0, 100.0]): + idx = i + 1 + for L in ref_val_Hg: + sx_all = get_sx(N) + sx_all = np.append(sx_all, get_smx(N)) + sx_all = np.append(sx_all, get_s3x(N, get_sx(N), get_smx(N))) + sx_all = np.append(sx_all, get_s4x(N, get_sx(N), get_smx(N))) + aS3 = A_singlet_3(N, sx_all, nf) + + # here we have a different approximation for AggTF2, + # some terms are neglected + if N != 100: + np.testing.assert_allclose( + aS3[0, 0], ref_val_gg[L][idx] + ref_val_ggTF2[L][idx], rtol=6e-3 + ) + if N != 2: + np.testing.assert_allclose(aS3[0, 1], ref_val_gq[L][idx], rtol=2e-6) + np.testing.assert_allclose(aS3[1, 0], ref_val_qg[L][idx], rtol=2e-6) + np.testing.assert_allclose( + aS3[2, 0], ref_val_Hg[L][idx] + ref_val_Hgstfac[L][idx], rtol=2e-6 + ) + + # np.testing.assert_allclose(aS3[2, 1], ref_val_Hq[L][idx], rtol=3e-6) + + # here we have a different convention for (-1)^N, + # for even values qqNS is analitically continued + # as non singlet. The accuracy is worst for large N + # due to the approximations of F functions. + np.testing.assert_allclose( + aS3[1, 1], ref_val_qqNS[L][idx] + ref_val_qqPS[L][idx], rtol=3e-2 + ) + + # Here we test the critical parts + nf = 3 + ref_ggTF_app = [-28.9075, -180.659, -229.537, -281.337, -467.164] + for idx, N in enumerate([2.0, 4.0, 6.0, 10.0, 100.0]): + sx = get_sx(N) + smx = get_smx(N) + s3x = get_s3x(N, sx, smx) + s4x = get_s4x(N, sx, smx) + Aggtf2 = n3lo.aggTF2.A_ggTF2_3(N, sx, s3x) + if N != 100: + # Limited in the small N region + np.testing.assert_allclose(Aggtf2, ref_val_ggTF2[0][idx], rtol=15e-2) + np.testing.assert_allclose(Aggtf2, ref_ggTF_app[idx], rtol=3e-6) + + np.testing.assert_allclose( + n3lo.agg.A_gg_3(N, sx, smx, s3x, s4x, nf) - Aggtf2, + ref_val_gg[0][idx], + rtol=3e-6, + ) + + # odd numbers of qqNS + # Limited accuracy due to F functions + ref_qqNS_odd = [-40.95, -21.5988, 6.96633] + for N, ref in zip([3.0, 15.0, 101.0], ref_qqNS_odd): + sx = get_sx(N) + smx = get_smx(N) + s3x = get_s3x(N, sx, smx) + s4x = get_s4x(N, sx, smx) + np.testing.assert_allclose( + n3lo.aqqNS.A_qqNS_3(N, sx, smx, s3x, s4x, nf), ref, rtol=3e-2 + ) diff --git a/tests/test_matching_nnlo.py b/tests/test_matching_nnlo.py index 2f4ba2b8e..8cd477b23 100644 --- a/tests/test_matching_nnlo.py +++ b/tests/test_matching_nnlo.py @@ -76,7 +76,7 @@ def test_pegasus_sign(): def test_Bluemlein_2(): # Test against Blumlein OME implementation :cite:`Bierenbaum_2009`. - # For some OME only even moments are available in that code. + # For singlet OME only even moments are available in that code. # Note there is a minus sign in the definition of L. ref_val_gg = { 0: [-9.96091, -30.0093, -36.5914, -40.6765, -43.6823], diff --git a/tests/test_s_functions.py b/tests/test_s_functions.py index c01524d69..f936d9ccb 100644 --- a/tests/test_s_functions.py +++ b/tests/test_s_functions.py @@ -1,7 +1,8 @@ # -*- coding: utf-8 -*- -# Test G functions impleeted by muselli PhD +# Test some harmomics and the binomial factor import numpy as np +import scipy.special as sp import eko.matching_conditions.n3lo.s_functions as sf @@ -58,3 +59,9 @@ def test_Smx(): ] for i, sm in enumerate(smx): np.testing.assert_allclose(sm, refvals[f"Sm{i+1}"][j], atol=1e-06) + +def test_binomial(): + # TODO: is it working for large numbers?? + r1 = np.random.randint(1000) + r2 = np.random.randint(1000) + np.testing.assert_allclose(sf.binomial(r1,r2), sp.binom(r1, r2)) From 0edf1fd03af14cb40a1a01e193c207b383eec316 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 30 Sep 2021 17:34:29 +0200 Subject: [PATCH 42/71] Adding H22, H24, H25 --- .../matching_conditions/n3lo/cs_functions.py | 581 +++++++++++--- .../matching_conditions/n3lo/h_functions.py | 744 +++++++++++++++++- tests/test_cs_functions.py | 139 +--- 3 files changed, 1253 insertions(+), 211 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/cs_functions.py b/src/eko/matching_conditions/n3lo/cs_functions.py index d293b465a..4bdeb191a 100644 --- a/src/eko/matching_conditions/n3lo/cs_functions.py +++ b/src/eko/matching_conditions/n3lo/cs_functions.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- """This module contains some approximations for generalized harmonics sum""" -#import numba as nb +# import numba as nb import numpy as np import mpmath as mp from ...anomalous_dimensions.harmonics import zeta2, zeta3 @@ -8,13 +8,13 @@ ln2 = np.log(2) # @nb.njit("c16(c16)", cache=True) -def S111l211(H22,H24): +def S111l211(H22, H24): return complex(H24 + H22) # @nb.njit("c16(c16)", cache=True) def S12l21(H25): - return complex(-2.0 * H25) + return complex(2.0 * H25) # @nb.njit("c16(c16,c16)", cache=True) @@ -71,7 +71,7 @@ def S31l205(n, S1, S2, S3): (1 + n) * (2 + n) * (3 + n) * (4 + n) * (5 + n) ) + S1 # Mellin[PolyLog[3,x/2]/(-1+x)] - H26 = ( + H29 = ( -0.557968 + 1 / (-4 - 2 * n) - 0.53125 / (3 + n) @@ -80,7 +80,7 @@ def S31l205(n, S1, S2, S3): + 0.537106 * Snp5 ) return ( - H26 + H29 - 1.0 / 6.0 * ln2 ** 3 * S1 + 1.0 / 2.0 * ln2 * zeta2 * S1 - 7.0 / 8.0 * zeta3 * S1 @@ -93,96 +93,495 @@ def S31l205(n, S1, S2, S3): # @nb.njit("c16(c16,c16,c16)", cache=True) def S121l2051(n, S1, H23): + # HarmonicNumber S[1,N+15] + Hp15 = ( + 4339163001600 + + 12331635229440 * n + + 15170987111472 * n ** 2 + + 10827253382400 * n ** 3 + + 5048360535400 * n ** 4 + + 1636819264080 * n ** 5 + + 382417906871 * n ** 6 + + 65661024000 * n ** 7 + + 8352861660 * n ** 8 + + 785584800 * n ** 9 + + 53895842 * n ** 10 + + 2620800 * n ** 11 + + 85540 * n ** 12 + + 1680 * n ** 13 + + 15 * n ** 14 + ) / ( + (1 + n) + * (2 + n) + * (3 + n) + * (4 + n) + * (5 + n) + * (6 + n) + * (7 + n) + * (8 + n) + * (9 + n) + * (10 + n) + * (11 + n) + * (12 + n) + * (13 + n) + * (14 + n) + * (15 + n) + ) + S1 return complex( - ( - -1.0830401704283533e13 * H23 - + 4.3924567500723857e12 * n - - 4.719820298271499e13 * H23 * n - + 1.5347099809768277e13 * np.power(n, 2) - - 9.28277799319932e13 * H23 * np.power(n, 2) - + 2.4643473394818945e13 * np.power(n, 3) - - 1.1033270798041445e14 * H23 * np.power(n, 3) - + 2.4206702804354082e13 * np.power(n, 4) - - 8.928723061726825e13 * H23 * np.power(n, 4) - + 1.6319435638160908e13 * np.power(n, 5) - - 5.244803302936807e13 * H23 * np.power(n, 5) - + 8.024831718581373e12 * np.power(n, 6) - - 2.324477933964049e13 * H23 * np.power(n, 6) - + 2.9839764042451226e12 * np.power(n, 7) - - 7.966230808118927e12 * H23 * np.power(n, 7) - + 8.578892089462283e11 * np.power(n, 8) - - 2.1441872369411062e12 * H23 * np.power(n, 8) - + 1.9323035163842896e11 * np.power(n, 9) - - 4.573731355009803e11 * H23 * np.power(n, 9) - + 3.4319246716192318e10 * np.power(n, 10) - - 7.760339042151804e10 * H23 * np.power(n, 10) - + 4.809688527205751e9 * np.power(n, 11) - - 1.0460546339529638e10 * H23 * np.power(n, 11) - + 5.291841901984562e8 * np.power(n, 12) - - 1.1129708511703498e9 * H23 * np.power(n, 12) - + 4.517523002879353e7 * np.power(n, 13) - - 9.228190983574654e7 * H23 * np.power(n, 13) - + 2.930975307090889e6 * np.power(n, 14) - - 5.836196460364303e6 * H23 * np.power(n, 14) - + 139635.45571358403 * np.power(n, 15) - - 271841.80388733785 * H23 * np.power(n, 15) - + 4605.037890010919 * np.power(n, 16) - - 8787.237785103225 * H23 * np.power(n, 16) - + 93.90370458786407 * np.power(n, 17) - - 176.00794515276021 * H23 * np.power(n, 17) - + 0.8918045027331737 * np.power(n, 18) - - 1.6449340668482262 * H23 * np.power(n, 18) - + ( - -3.3026317142400005e12 - - 1.439265931975543e13 * n - - 2.830698051067102e13 * np.power(n, 2) - - 3.364494784620761e13 * np.power(n, 3) - - 2.722732245440367e13 * np.power(n, 4) - - 1.5993546865744523e13 * np.power(n, 5) - - 7.088282367887105e12 * np.power(n, 6) - - 2.4292290561525176e12 * np.power(n, 7) - - 6.538502415094675e11 * np.power(n, 8) - - 1.3947174479682452e11 * np.power(n, 9) - - 2.3664442495912846e10 * np.power(n, 10) - - 3.1898477113313265e9 * np.power(n, 11) - - 3.393902581329089e8 * np.power(n, 12) - - 2.8140522428972498e7 * np.power(n, 13) - - 1.7796946084567667e6 * np.power(n, 14) - - 82895.66604158795 * np.power(n, 15) - - 2679.5876073711893 * np.power(n, 16) - - 53.67200935767826 * np.power(n, 17) - - 0.501607564090451 * np.power(n, 18) + -1.6449340668482262 * H23 + - ( + -1.0970571006583727e12 + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) ) - * S1 - + 0.631966197838168 - * n - * (2.0 + 3.0 * n + 1.0 * np.power(n, 2)) - * np.power( - 1.8144e6 - + 2.59272e6 * n - + 1.580508e6 * np.power(n, 2) - + 537628.0 * np.power(n, 3) - + 111769.0 * np.power(n, 4) - + 14560.0 * np.power(n, 5) - + 1162.0 * np.power(n, 6) - + 52.0 * np.power(n, 7) - + 1.0 * np.power(n, 8), - 2, + - (1.9125237074510933e12 * n) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (1.4994381266170989e12 * np.power(n, 2)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (7.009994340470765e11 * np.power(n, 3)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (2.183094685920398e11 * np.power(n, 4)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (4.787984810093941e10 * np.power(n, 5)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (7.616207507383221e9 * np.power(n, 6)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (8.904886102155218e8 * np.power(n, 7)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (7.659214612862481e7 * np.power(n, 8)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (4.790018361468757e6 * np.power(n, 9)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (211858.07625410164 * np.power(n, 10)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (6279.1827747379675 * np.power(n, 11)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (111.83851326006433 * np.power(n, 12)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + - (0.9044729718388043 * np.power(n, 13)) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (3.3061524774118085e11 * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (6.011342290466014e11 * n * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (4.9187554395002936e11 * np.power(n, 2) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (2.401640821300795e11 * np.power(n, 3) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (7.817131339252147e10 * np.power(n, 4) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (1.7933250800932724e10 * np.power(n, 5) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (2.986455305719683e9 * np.power(n, 6) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (3.659103962777948e8 * np.power(n, 7) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (3.3015840269221872e7 * np.power(n, 8) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (2.1686039669867153e6 * np.power(n, 9) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (100870.34556855283 * np.power(n, 10) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (3148.7061275553474 * np.power(n, 11) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (59.16149300208377 * np.power(n, 12) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) + ) + + (0.5056537863425963 * np.power(n, 13) * Hp15) + / ( + (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + * (9.0 + n) + * (10.0 + n) + * (11.0 + n) + * (12.0 + n) + * (13.0 + n) + * (14.0 + n) + * (15.0 + n) ) - * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - * np.power(10.0 + n, 2) ) + + 0.631966197838168 + * n + * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) ) diff --git a/src/eko/matching_conditions/n3lo/h_functions.py b/src/eko/matching_conditions/n3lo/h_functions.py index 268797be8..95be31c1f 100644 --- a/src/eko/matching_conditions/n3lo/h_functions.py +++ b/src/eko/matching_conditions/n3lo/h_functions.py @@ -123,8 +123,29 @@ def H21(n, S1): ) -def H22(): - return 0.0 +@nb.njit("c16(c16,c16)", cache=True) +def H22(n, S1): + return complex( + -0.09370981275434521 * n + - (0.42787353308023546 * n) / (2.0 + n) + + (0.20524636633955842 * n) / (3.0 + n) + - (0.012972991934051131 * n) / (4.0 + n) + - (0.005763373593698165 * n) / (5.0 + n) + + (0.0009292194616465901 * n) / (6.0 + n) + - (0.0061122598440842245 * n) / (7.0 + n) + + (0.006638305902069104 * n) / (8.0 + n) + - (0.005884194432060406 * n) / (9.0 + n) + + (0.002785480879571394 * n) / (10.0 + n) + - (0.0006792903101534132 * n) / (11.0 + n) + - 0.33739608529577086 * (-1.0 + 1 / (1.0 + n)) + - 0.041666666666666664 + * n + * (-1.606170709478783 - 6.0 / (2.0 + n) + 4.0 / (3.0 + n)) + - 0.01925408834888737 + * n + * (-1.391186796731926 + 30.0 / (1.0 + n) - 3.0 / (2.0 + n) + 4.0 / (3.0 + n)) + + 0.2402265069591007 * S1 + ) @nb.njit("c16(c16,c16)", cache=True) @@ -150,14 +171,716 @@ def H23(n, S1): ) -# @nb.njit("c16()", cache=True) -def H24(): - return 0.0 +def H24(n, S1): + return complex( + complex(2.7620719062289236, 0.7546938294602481) * (-1.0 + np.power(2.0, n)) + - 1.0 + * np.power(2.0, n) + * n + * ( + (6.151252465559908 * (1.0 - 1.0 / np.power(2.0, 1.0 * n))) / n + - (105.96211347491152 * (1.0 - 1.0 * np.power(2.0, -1.0 - 1.0 * n))) + / (1.0 + n) + + (912.428887509948 * (1.0 - 1.0 * np.power(2.0, -2.0 - 1.0 * n))) + / (2.0 + n) + - (4622.246477438636 * (1.0 - 1.0 * np.power(2.0, -3.0 - 1.0 * n))) + / (3.0 + n) + + (15939.451978244468 * (1.0 - 1.0 * np.power(2.0, -4.0 - 1.0 * n))) + / (4.0 + n) + - (39590.27112365593 * (1.0 - 1.0 * np.power(2.0, -5.0 - 1.0 * n))) + / (5.0 + n) + + (72858.10340264498 * (1.0 - 1.0 * np.power(2.0, -6.0 - 1.0 * n))) + / (6.0 + n) + - (100586.39794650947 * (1.0 - 1.0 * np.power(2.0, -7.0 - 1.0 * n))) + / (7.0 + n) + + (104186.07179796268 * (1.0 - 1.0 * np.power(2.0, -8.0 - 1.0 * n))) + / (8.0 + n) + - (79971.67810898797 * (1.0 - 1.0 * np.power(2.0, -9.0 - 1.0 * n))) + / (9.0 + n) + + (44221.656964985224 * (1.0 - 1.0 * np.power(2.0, -10.0 - 1.0 * n))) + / (10.0 + n) + - (16684.086864855977 * (1.0 - 1.0 * np.power(2.0, -11.0 - 1.0 * n))) + / (11.0 + n) + + (3850.0341714476917 * (1.0 - 1.0 * np.power(2.0, -12.0 - 1.0 * n))) + / (12.0 + n) + - (410.4937387157474 * (1.0 - 1.0 * np.power(2.0, -13.0 - 1.0 * n))) + / (13.0 + n) + - ( + 3.8888888888888893 + * ( + -1.3862943611198906 * np.power(2.0, -1.0 - 1.0 * n) + + S1 + + mp.betainc(1.0 + n, 0.0, x2=0.5) + ) + ) + / n + + ( + 6.666666666666667 + * ( + -1.3862943611198906 * np.power(2.0, -2.0 - 1.0 * n) + + 1 / (1.0 + n) + + S1 + + mp.betainc(2.0 + n, 0.0, x2=0.5) + ) + ) + / (1.0 + n) + - ( + 3.666666666666665 + * ( + -1.3862943611198906 * np.power(2.0, -3.0 - 1.0 * n) + + (3.0 + 2.0 * n) / ((1.0 + n) * (2.0 + n)) + + S1 + + mp.betainc(3.0 + n, 0.0, x2=0.5) + ) + ) + / (2.0 + n) + + ( + 0.8888888888888886 + * ( + -1.3862943611198906 * np.power(2.0, -4.0 - 1.0 * n) + + (11.0 + 12.0 * n + 3.0 * np.power(n, 2)) + / ((1.0 + n) * (2.0 + n) * (3.0 + n)) + + S1 + + mp.betainc(4.0 + n, 0.0, x2=0.5) + ) + ) + / (3.0 + n) + + ( + 0.4804530139182014 + * np.power(2.0, -1.0 - 1.0 * n) + * ( + complex(0.0, 3.141592653589793) * np.power(2.0, n) + + S1 + + mp.betainc(1.0 + n, 0.0, x2=2.0) + ) + ) + / n + + 1.3333333333333333 + * ( + 0.6931471805599453 + * ( + ( + 0.6931471805599453 + - 0.6931471805599453 * np.power(2.0, -3.0 - 1.0 * n) + ) + / (3.0 + n) + + mp.hyper(list([1.0, 1.0, -2.0 - 1.0 * n]), list([2.0, 2.0]), 0.5) + ) + + mp.hyper( + list([1.0, 1.0, 1.0, -2.0 - 1.0 * n]), list([2.0, 2.0, 2.0]), 0.5 + ) + ) + - 5.0 + * ( + 0.6931471805599453 + * ( + ( + 0.6931471805599453 + - 0.6931471805599453 * np.power(2.0, -2.0 - 1.0 * n) + ) + / (2.0 + n) + + mp.hyper(list([1.0, 1.0, -1.0 - 1.0 * n]), list([2.0, 2.0]), 0.5) + ) + + mp.hyper( + list([1.0, 1.0, 1.0, -1.0 - 1.0 * n]), list([2.0, 2.0, 2.0]), 0.5 + ) + ) + - 3.3333333333333335 + * ( + 0.6931471805599453 + * ( + (0.6931471805599453 - 0.6931471805599453 / np.power(2.0, 1.0 * n)) + / n + + mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), 0.5) + ) + + mp.hyper( + list([1.0, 1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0, 2.0]), 0.5 + ) + ) + + 7.0 + * ( + 0.6931471805599453 + * ( + ( + 0.6931471805599453 + - 0.6931471805599453 * np.power(2.0, -1.0 - 1.0 * n) + ) + / (1.0 + n) + + mp.hyper(list([1.0, 1.0, -1.0 * n]), list([2.0, 2.0]), 0.5) + ) + + mp.hyper(list([1.0, 1.0, 1.0, -1.0 * n]), list([2.0, 2.0, 2.0]), 0.5) + ) + ) + ) # @nb.njit("c16()", cache=True) -def H25(): - return 0.0 +def H25(n, S1, S2): + return complex( + -0.9765080063055425 + + 0.3465324280753968 / np.power(1.0 + n, 2) + + 0.5313147349319273 / (1.0 + n) + + 0.09653242807539683 / np.power(2.0 + n, 2) + + 0.10802793979194095 / (2.0 + n) + + 0.034032428075396824 / np.power(3.0 + n, 2) + + 0.03345624100694436 / (3.0 + n) + + 0.013199094742063492 / np.power(4.0 + n, 2) + + 0.012071230300834391 / (4.0 + n) + + 0.005386594742063492 / np.power(5.0 + n, 2) + + 0.00470289295270982 / (5.0 + n) + + 0.0022615947420634923 / np.power(6.0 + n, 2) + + 0.001911808013459991 / (6.0 + n) + + 0.0009595114087301587 / np.power(7.0 + n, 2) + + 0.0007922587332170066 / (7.0 + n) + + 0.00040147569444444443 / np.power(8.0 + n, 2) + + 0.00032573846345300655 / (8.0 + n) + - complex(28823.33170068027, 67307.76191106241) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + (1801.458231292517 * np.power(2.0, 4.0 + n)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (complex(60934.848533133685, 182932.88147970886) * n) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + (45750.521632653064 * np.power(2.0, n) * n) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (complex(55310.196621119074, 197189.03938448254) * np.power(n, 2)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + (3.15990922e7 * np.power(2.0, -10.0 + n) * np.power(n, 2)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (complex(27899.370995930713, 112319.8276890854) * np.power(n, 3)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + (9.26168518740136e7 * np.power(2.0, -13.0 + n) * np.power(n, 3)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (complex(8521.952753241852, 37474.99868902381) * np.power(n, 4)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + (3.967415195020408e7 * np.power(2.0, -14.0 + n) * np.power(n, 4)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (complex(1612.5907721691867, 7572.123214994521) * np.power(n, 5)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + (4.965773963265306e6 * np.power(2.0, -14.0 + n) * np.power(n, 5)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (complex(184.6934149990644, 911.45927587897) * np.power(n, 6)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + (336550.07972789113 * np.power(2.0, -14.0 + n) * np.power(n, 6)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (complex(11.719635588798857, 60.09621599202) * np.power(n, 7)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + (9538.758911564626 * np.power(2.0, -14.0 + n) * np.power(n, 7)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (complex(0.315923902660914, 1.6693393331116668) * np.power(n, 8)) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + 0.00015733506944444445 / np.power(9.0 + n, 2) + + 0.0001259954994491137 / (9.0 + n) + + 0.000048828125 / np.power(10.0 + n, 2) + + 0.000038727889675778575 / (10.0 + n) + + 0.5313147349319273 * S1 + - (21424.726033195955 * S1) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (58229.344683079005 * n * S1) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (62767.220683165644 * np.power(n, 2) * S1) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (35752.51156789575 * np.power(n, 3) * S1) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (11928.662567440875 * np.power(n, 4) * S1) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (2410.2816787345455 * np.power(n, 5) * S1) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (290.1264983661953 * np.power(n, 6) * S1) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (19.12921967249639 * np.power(n, 7) * S1) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - (0.5313672131248997 * np.power(n, 8) * S1) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + 0.3465324280753968 * S2 + + ( + 3.004709057142857e6 + * np.power(2.0, -7.0 + n) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - ( + 1036.3084621143826 + * np.power(2.0, 6.0 + n) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + ( + 4.1293287328163266e7 + * np.power(2.0, -10.0 + n) + * n + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - ( + 14241.839150771944 + * np.power(2.0, 3.0 + n) + * n + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + ( + 1.165159401047619e8 + * np.power(2.0, -12.0 + n) + * np.power(n, 2) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - ( + 40185.73925310217 + * np.power(2.0, 1.0 + n) + * np.power(n, 2) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + ( + 2.1967761773333333e7 + * np.power(2.0, -11.0 + n) + * np.power(n, 3) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - ( + 7576.5663119029305 + * np.power(2.0, 2.0 + n) + * np.power(n, 3) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + ( + 3.839350461904762e7 + * np.power(2.0, -14.0 + n) + * np.power(n, 4) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - ( + 13241.719238128222 + * np.power(2.0, -1.0 + n) + * np.power(n, 4) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + ( + 4.874305803809524e6 + * np.power(2.0, -14.0 + n) + * np.power(n, 5) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - ( + 1681.1226163188874 + * np.power(2.0, -1.0 + n) + * np.power(n, 5) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + ( + 333856.5619047619 + * np.power(2.0, -14.0 + n) + * np.power(n, 6) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - ( + 115.14538467937584 + * np.power(2.0, -1.0 + n) + * np.power(n, 6) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + + ( + 9538.758911564626 + * np.power(2.0, -14.0 + n) + * np.power(n, 7) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + - ( + 3.2898681336964524 + * np.power(2.0, -1.0 + n) + * np.power(n, 7) + * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) + ) + / ( + (1.0 + n) + * (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + * (8.0 + n) + ) + ) # @nb.njit("c16(c16,c16,c16)", cache=True) @@ -420,17 +1143,16 @@ def H26(n, S1, S2): # @nb.njit("c16(c16,c16,c16)", cache=True) -def H27(n, S1, S2, S3, H21, H22, H23, H24, H25): +def H27(n, S1, S2, S3, H21, H23, H24, H25): """Linear combination of + S1111l21105 + S112l2051 - S112l2105 + S121l2105 - S13l205""" return complex( 0.125 * ( complex(0.0, -3.7763731361630786) + 6.579736267392905 * H21 - - 5.545177444479562 * H22 - 4.657924211720099 * H23 + 5.545177444479562 * H24 - - 11.090354888959125 * H25 + + 11.090354888959125 * H25 + ( np.power(n, 2) * (166512.82004488667 - 201720.28849894297 * S1) + n * (90242.14129258736 - 187136.5352923044 * S1) @@ -979,6 +1701,6 @@ def H27(n, S1, S2, S3, H21, H22, H23, H24, H25): * np.power(8.0 + n, 3) * np.power(9.0 + n, 3) ) - - 1.2020569031595942 * mp.betainc(2.0, 1.0 + n, 0.0) + - 1.2020569031595942 * mp.betainc(1.0 + n, 0.0, x2=2.0) ) ) diff --git a/tests/test_cs_functions.py b/tests/test_cs_functions.py index e7aef0ec8..8dec308ca 100644 --- a/tests/test_cs_functions.py +++ b/tests/test_cs_functions.py @@ -140,36 +140,39 @@ def test_S1l05(): np.testing.assert_allclose(test, vals, rtol=1e-05) -# TODO: still on going -# def test_S111l211(): -# for N, vals in zip(testN, refvals["S111l211"]): -# S1 = harmonics.harmonic_S1(N) -# H24 = hf.H24(n,S1) -# test = csf.S111l211(H24) -# np.testing.assert_allclose(test, vals), rtol=1e-05) -# -# -# def test_S12l21(): -# for N, vals in zip(testN, refvals["S12l21"]): -# test = csf.S12l21(H25) -# np.testing.assert_allclose(test - 1.0j * imtest, vals), rtol=8e-03) +def test_S111l211(): + for N, vals in zip(testN, refvals["S111l211"]): + S1 = harmonics.harmonic_S1(N) + H22 = hf.H22(N, S1) + H24 = hf.H24(N, S1) + test = csf.S111l211(H22, H24) + np.testing.assert_allclose(test, vals, rtol=2e-05) + + +def test_S12l21(): + for N, vals in zip(testN, refvals["S12l21"]): + S1 = harmonics.harmonic_S1(N) + S2 = harmonics.harmonic_S2(N) + H25 = hf.H25(N, S1, S2) + test = csf.S12l21(H25) + np.testing.assert_allclose(test, vals, rtol=1e-05) def test_S21l21(): for N, vals in zip(testN, refvals["S21l21"]): S1 = harmonics.harmonic_S1(N) test = csf.S21l21(N, S1) - rtol = 15e-02 + rtol = 15e-03 if N == 100 + 5j: - rtol = 25e-01 + rtol = 25e-02 np.testing.assert_allclose(test, vals, rtol=rtol) def test_S3l2(): for N, vals in zip(testN, refvals["S3l2"]): test = csf.S3l2(N) - # TODO: here Mathematica and MPmath do not agree on LerchPhi, - # when the 3rd argument is complez and first real... + # TODO: here Mathematica and mpmath do not agree on LerchPhi, + # when the 3rd argument is complex and first real... np.testing.assert_allclose(np.real(test), np.real(vals), rtol=1e-05) for N, vals in zip(testNinteger, refvalsinteger["S3l2"]): @@ -195,94 +198,12 @@ def test_S1111l21051(): np.testing.assert_allclose(test, vals, rtol=rtol) -# TODO: still on going -# def test_S1111l21105(): -# for N, vals in zip(testN, refvals["S1111l21105"]): -# S1 = harmonics.harmonic_S1(N) -# H21 = hf.H21(N,S1) -# H23 = hf.H23(N,S1) -# H24 = hf.H24(N,S1) -# test = csf.S1111l21105(N, S1, H21,H23,H24) -# np.testing.assert_allclose(test, vals), rtol=15e-03) - - -# def test_S112l2051(): -# for N, vals in zip(testN, refvals["S112l2051"]): -# S1 = harmonics.harmonic_S1(N) -# test = csf.S112l2051(N, S1) -# np.testing.assert_allclose(test, vals, rtol=5e-03) - - -# def test_S112l2105(): -# for N, vals in zip(testN, refvals["S112l2105"]): -# S1 = harmonics.harmonic_S1(N) -# S2 = harmonics.harmonic_S2(N) -# H21 = hf.H21(N, S1) -# H23 = hf.H23(N, S1) -# test = csf.S112l2105(N, S1, S2, H21, H23) -# rtol = 6e-03 -# if N == 100 + 5j: -# rtol = 2e-01 -# np.testing.assert_allclose(test, vals, rtol=rtol) - - def test_S121l2051(): for N, vals in zip(testN, refvals["S121l2051"]): S1 = harmonics.harmonic_S1(N) H23 = hf.H23(N, S1) test = csf.S121l2051(N, S1, H23) - np.testing.assert_allclose(test, vals, rtol=15e-01) - - -# TODO: still on going -# def test_S121l2105(): -# for N, vals in zip(testN, refvals["S121l2105"]): -# S1 = harmonics.harmonic_S1(N) -# S2 = harmonics.harmonic_S2(N) -# test = csf.S121l2105(N, S1, S2,H23,H25) -# np.testing.assert_allclose(test, vals), rtol=2e-05) - - -# def test_S13l205(): -# for N, vals in zip(testN, refvals["S13l205"]): -# S1 = harmonics.harmonic_S1(N) -# S2 = harmonics.harmonic_S2(N) -# S3 = harmonics.harmonic_S3(N) -# test = csf.S13l205(N, S1, S2, S3) -# np.testing.assert_allclose(test, vals, rtol=3e-03) - - -# not given alone -# def test_S211l2051(): -# for N, vals in zip(testNinteger, refvalsinteger["S211l2051"]): -# S1 = harmonics.harmonic_S1(N) -# S2 = harmonics.harmonic_S2(N) -# test = csf.S211l2051(N,S1,S2) -# np.testing.assert_allclose(test, vals, rtol=1e-03) -# for N, vals in zip(testN, refvals["S211l2051"]): -# S1 = harmonics.harmonic_S1(N) -# S2 = harmonics.harmonic_S2(N) -# test = csf.S211l2051(N,S1,S2) -# # same as S3l2 for complex part -# np.testing.assert_allclose(np.real(test), np.real(vals), rtol=1e-03) - -# not given alone -# def test_S211l2105(): -# for N, vals in zip(testN, refvals["S211l2105"]): -# S1 = harmonics.harmonic_S1(N) -# S2 = harmonics.harmonic_S2(N) -# test = csf.S211l2105(N, S1, S2) -# if N == 100 + 5j: -# continue -# np.testing.assert_allclose(test, vals, rtol=2e-02) - -# not given alone -# def test_S22l205(): -# for N, vals in zip(testN, refvals["S22l205"]): -# S1 = harmonics.harmonic_S1(N) -# S2 = harmonics.harmonic_S2(N) -# test = csf.S22l205(N, S1, S2) -# np.testing.assert_allclose(test, vals, rtol=1e-04) + np.testing.assert_allclose(test, vals, rtol=2e-1) def test_S31l205(): @@ -307,9 +228,10 @@ def test_S211l2051_S211l2105_S22l205(): test = hf.H26(N, S1, S2) rtol = 2e-02 if N == 5j + 100: - rtol = 25e-01 + rtol = 25e-02 np.testing.assert_allclose(test, vals, rtol=rtol) + def test_S1111l21105_S112l2051_S112l2105_S121l2105_S13l205(): for N, vals in zip( testN, @@ -322,13 +244,12 @@ def test_S1111l21105_S112l2051_S112l2105_S121l2105_S13l205(): S1 = harmonics.harmonic_S1(N) S2 = harmonics.harmonic_S2(N) S3 = harmonics.harmonic_S3(N) - H21 = hf.H21(N,S1) - H22 = hf.H22() - H23 = hf.H23(N,S1) - H24 = hf.H24() - H25 = hf.H25() - test = hf.H27(N, S1, S2, S3, H21, H22, H23,H24,H25) - rtol = 2e-03 + H21 = hf.H21(N, S1) + H23 = hf.H23(N, S1) + H24 = hf.H24(N, S1) + H25 = hf.H25(N, S1, S2) + test = hf.H27(N, S1, S2, S3, H21, H23, H24, H25) + rtol = 5e-03 if N == 5j + 100: - rtol = 2e-01 + rtol = 15e-02 np.testing.assert_allclose(test, vals, rtol=rtol) From a1ab220a75bc79593ec37fb78b251cfef1e6252f Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 4 Oct 2021 09:30:49 +0200 Subject: [PATCH 43/71] Adding aHq N3LO ome --- src/eko/matching_conditions/n3lo/aHq.py | 1580 ++++++++++++++++++++++- tests/test_matching_n3lo.py | 45 +- 2 files changed, 1605 insertions(+), 20 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/aHq.py b/src/eko/matching_conditions/n3lo/aHq.py index a7a738975..8de1cd1e5 100644 --- a/src/eko/matching_conditions/n3lo/aHq.py +++ b/src/eko/matching_conditions/n3lo/aHq.py @@ -1,21 +1,1571 @@ # -*- coding: utf-8 -*- -"""This module contains the |N3LO| |OME| for the matching conditions in the |VFNS| the experssions are taken from :cite:`Bierenbaum_2009`""" -import numba as nb +# pylint: disable=too-many-lines +"""This module contains the |OME| aHq, the experssions are taken from :cite:`Bierenbaum_2009`""" import numpy as np -from ...anomalous_dimensions import harmonics -from . import g_functions as gf +from . import cs_functions as cs +from . import h_functions as hf -zeta2 = harmonics.zeta2 -zeta3 = harmonics.zeta3 -zeta4 = harmonics.zeta4 -zeta5 = harmonics.zeta5 -li4half = 0.517479 -li5half = 0.508401 +def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals + S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] + Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] + S21, Sm21 = s3x[0], s3x[2] + S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] + H22 = hf.H22(n, S1) + H24 = hf.H24(n, S1) + H25 = hf.H25(n, S1, S2) + S1l05 = cs.S1l05(n) + S111l211 = cs.S111l211(H22, H24) + S12l21 = cs.S12l21(H25) + S21l21 = cs.S21l21(n, S1) + S3l2 = cs.S3l2(n) + S31l205 = cs.S31l205(n, S1, S2, S3) -@nb.njit("c16(c16,c16[:],c16[:],u4,f8)", cache=True) -def A_Qq_3(n, sx, spx, nf, L): - S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] - Sp1p, Sp2p, Sp3p, Sp4p, Sp5p = spx[0], spx[1], spx[2], spx[3], spx[4] - return 0.0 + H1 = S111l211 + S12l21 - S21l21 - S3l2 + + if np.abs(n) <= 32: + H21 = hf.H21(n, S1) + H23 = hf.H23(n, S1) + H26 = hf.H26(n, S1, S2) + H27 = hf.H27(n, S1, S2, S3, H21, H23, H24, H25) + S1111l20511 = cs.S1111l20511(n, S1) + S1111l21051 = cs.S1111l21051(n, S1, H21) + S121l2051 = cs.S121l2051(n, S1, H23) + + H2 = (-H26 + H27 + S1111l20511 + S1111l21051 - S121l2051 - S31l205) - S1l05 * H1 + else: + H2 = ( + -S31l205 + + S1l05 * S3l2 + # Expansion of H27 + S1111l20511 + S1111l21051 - S121l2051 - S1l05 * (S111l211 + S12l21) + + ( + -0.621442 + + 2.51724 / n ** 4 + + (328.162 * 2 ** (-2 - n)) / n ** 4 + - (44.4671 * 2 ** (-n)) / n ** 4 + + 1.5302 / n ** 3 + - (75.7296 * 2 ** (-2 - n)) / n ** 3 + + (10.2616 * 2 ** (-n)) / n ** 3 + + 0.072467 / n ** 2 + + (25.2432 * 2 ** (-2 - n)) / n ** 2 + - (3.42054 * 2 ** (-n)) / n ** 2 + + 1.64493 / n + - (25.2432 * 2 ** (-3 - n)) / n + + (3.42054 * 2 ** (-1 - n)) / n + - (6.75 * (0.577216 + np.log(n))) / n ** 4 + + (1.83333 * (0.577216 + np.log(n))) / n ** 3 + - (0.5 * (0.577216 + np.log(n))) / n ** 2 + ) + # Expansion of - H26 + S1l05 * (S21l21) + - ( + 1.5806185221185012 + - 0.22916666666666666 / n ** 4 + - 0.05555555555555555 / n ** 3 + + 0.25 / n ** 2 + + (2.75 / n ** 4 - 1.1666666666666667 / n ** 3 + 0.5 / n ** 2) + * (0.5772156649015329 + np.log(n)) + ) + ) + return ( + 0.3333333333333333 + * nf + * ( + ( + 2.9243272299524024 + * ( + -48.0 + - 104.0 * n + - 56.0 * np.power(n, 2) + - 86.0 * np.power(n, 3) + - 11.0 * np.power(n, 4) + + 68.0 * np.power(n, 5) + + 37.0 * np.power(n, 6) + + 8.0 * np.power(n, 7) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 0.13168724279835392 + * ( + -6912.0 + - 35712.0 * n + - 77952.0 * np.power(n, 2) + - 84608.0 * np.power(n, 3) + - 24944.0 * np.power(n, 4) + - 12856.0 * np.power(n, 5) + - 8896.0 * np.power(n, 6) + + 59452.0 * np.power(n, 7) + + 89880.0 * np.power(n, 8) + + 56186.0 * np.power(n, 9) + + 23003.0 * np.power(n, 10) + + 7714.0 * np.power(n, 11) + + 1663.0 * np.power(n, 12) + + 158.0 * np.power(n, 13) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + - ( + 0.3950617283950617 + * ( + 576.0 + + 2112.0 * n + + 3040.0 * np.power(n, 2) + + 1648.0 * np.power(n, 3) + + 2244.0 * np.power(n, 4) + + 1848.0 * np.power(n, 5) + - 20.0 * np.power(n, 6) + + 30.0 * np.power(n, 7) + + 417.0 * np.power(n, 8) + + 176.0 * np.power(n, 9) + + 25.0 * np.power(n, 10) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 0.5925925925925926 + * ( + -48.0 + - 104.0 * n + - 56.0 * np.power(n, 2) + - 86.0 * np.power(n, 3) + - 11.0 * np.power(n, 4) + + 68.0 * np.power(n, 5) + + 37.0 * np.power(n, 6) + + 8.0 * np.power(n, 7) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 7.703703703703703 + * ( + -48.0 + - 104.0 * n + - 56.0 * np.power(n, 2) + - 86.0 * np.power(n, 3) + - 11.0 * np.power(n, 4) + + 68.0 * np.power(n, 5) + + 37.0 * np.power(n, 6) + + 8.0 * np.power(n, 7) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + 29.917860700861013 + - 8.772981689857207 * S1 + - 0.5925925925925926 * np.power(S1, 3) + - 23.11111111111111 * S1 * S2 + - 65.18518518518519 * S3 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 0.3333333333333333 + * ( + ( + -5.848654459904805 + * ( + 24.0 + + 124.0 * n + + 162.0 * np.power(n, 2) + + 193.0 * np.power(n, 3) + + 84.0 * np.power(n, 4) + + 29.0 * np.power(n, 5) + + 8.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + 1.1851851851851851 + * ( + ( + -0.2222222222222222 + * ( + 207360.0 + + 1.026432e6 * n + + 2.192832e6 * np.power(n, 2) + + 3.109248e6 * np.power(n, 3) + + 4.514336e6 * np.power(n, 4) + + 8.472792e6 * np.power(n, 5) + + 1.2693884e7 * np.power(n, 6) + + 1.2958212e7 * np.power(n, 7) + + 9.333994e6 * np.power(n, 8) + + 4.877344e6 * np.power(n, 9) + + 1.87144e6 * np.power(n, 10) + + 559575.0 * np.power(n, 11) + + 145948.0 * np.power(n, 12) + + 32280.0 * np.power(n, 13) + + 4670.0 * np.power(n, 14) + + 293.0 * np.power(n, 15) + ) + ) + / (np.power(n, 5) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + + ( + 0.6666666666666666 + * ( + -17280.0 + - 76896.0 * n + - 82368.0 * np.power(n, 2) + + 155864.0 * np.power(n, 3) + + 599060.0 * np.power(n, 4) + + 886552.0 * np.power(n, 5) + + 837697.0 * np.power(n, 6) + + 553796.0 * np.power(n, 7) + + 251778.0 * np.power(n, 8) + + 79990.0 * np.power(n, 9) + + 20431.0 * np.power(n, 10) + + 4658.0 * np.power(n, 11) + + 746.0 * np.power(n, 12) + + 52.0 * np.power(n, 13) + ) + * S1 + ) + / (np.power(n, 4) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + - ( + 1.0 + * ( + -7200.0 + - 3960.0 * n + + 22748.0 * np.power(n, 2) + + 37370.0 * np.power(n, 3) + + 40683.0 * np.power(n, 4) + + 34749.0 * np.power(n, 5) + + 18410.0 * np.power(n, 6) + + 5724.0 * np.power(n, 7) + + 1095.0 * np.power(n, 8) + + 133.0 * np.power(n, 9) + + 8.0 * np.power(n, 10) + ) + * np.power(S1, 2) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + + ( + ( + 7200.0 + - 26280.0 * n + - 46100.0 * np.power(n, 2) + - 47454.0 * np.power(n, 3) + - 33693.0 * np.power(n, 4) + - 7014.0 * np.power(n, 5) + + 5392.0 * np.power(n, 6) + + 3284.0 * np.power(n, 7) + + 625.0 * np.power(n, 8) + + 40.0 * np.power(n, 9) + ) + * S2 + ) + / (np.power(n, 3) * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + ) + ) + / ((-1.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + -136.76736320393604 + + 17.545963379714415 * S1 + + 1.1851851851851851 * np.power(S1, 3) + - 17.77777777777778 * S1 * S2 + + 42.666666666666664 * S21 + - 18.962962962962962 * S3 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 0.3333333333333333 + * ( + ( + 5.848654459904805 + * ( + 24.0 + + 124.0 * n + + 162.0 * np.power(n, 2) + + 193.0 * np.power(n, 3) + + 84.0 * np.power(n, 4) + + 29.0 * np.power(n, 5) + + 8.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + 0.3950617283950617 + * ( + 864.0 + + 5616.0 * n + + 15984.0 * np.power(n, 2) + + 32344.0 * np.power(n, 3) + + 63406.0 * np.power(n, 4) + + 128195.0 * np.power(n, 5) + + 192416.0 * np.power(n, 6) + + 196942.0 * np.power(n, 7) + + 148026.0 * np.power(n, 8) + + 87182.0 * np.power(n, 9) + + 39593.0 * np.power(n, 10) + + 12793.0 * np.power(n, 11) + + 2599.0 * np.power(n, 12) + + 248.0 * np.power(n, 13) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + - ( + 1.1851851851851851 + * (2.0 + n + np.power(n, 2)) + * ( + 86.0 + + 230.0 * n + + 224.0 * np.power(n, 2) + + 105.0 * np.power(n, 3) + + 43.0 * np.power(n, 4) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 4) * (2.0 + n)) + + ( + 1.7777777777777777 + * (2.0 + n + np.power(n, 2)) + * (16.0 + 27.0 * n + 13.0 * np.power(n, 2) + 8.0 * np.power(n, 3)) + * np.power(S1, 2) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 1.7777777777777777 + * ( + 96.0 + + 400.0 * n + + 628.0 * np.power(n, 2) + + 796.0 * np.power(n, 3) + + 565.0 * np.power(n, 4) + + 158.0 * np.power(n, 5) + + 37.0 * np.power(n, 6) + + 8.0 * np.power(n, 7) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + 17.095920400492005 + - 17.545963379714415 * S1 + - 1.7777777777777777 * np.power(S1, 3) + - 5.333333333333333 * S1 * S2 + + 17.77777777777778 * S3 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 0.3333333333333333 + * nf + * ( + ( + -2.9243272299524024 + * ( + -48.0 + - 104.0 * n + - 56.0 * np.power(n, 2) + - 86.0 * np.power(n, 3) + - 11.0 * np.power(n, 4) + + 68.0 * np.power(n, 5) + + 37.0 * np.power(n, 6) + + 8.0 * np.power(n, 7) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 10.666666666666666 + * ( + -32.0 + - 208.0 * n + - 592.0 * np.power(n, 2) + - 904.0 * np.power(n, 3) + - 682.0 * np.power(n, 4) + - 473.0 * np.power(n, 5) + - 400.0 * np.power(n, 6) + + 38.0 * np.power(n, 7) + + 374.0 * np.power(n, 8) + + 252.0 * np.power(n, 9) + + 62.0 * np.power(n, 10) + + 5.0 * np.power(n, 11) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + + ( + 21.333333333333332 + * (2.0 + 5.0 * n + np.power(n, 2)) + * (4.0 + 4.0 * n + 7.0 * np.power(n, 2) + 5.0 * np.power(n, 3)) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * (4.273980100123001 + 8.772981689857207 * S1 + 21.333333333333332 * S3) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 0.8888888888888888 + * ( + ( + -1.6027425375461255 + * np.power(2.0 + n + np.power(n, 2), 2) + * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 3.2898681336964524 + * (2.0 + n + np.power(n, 2)) + * ( + -12.0 + - 28.0 * n + + 21.0 * np.power(n, 2) + + 106.0 * np.power(n, 3) + + 151.0 * np.power(n, 4) + + 108.0 * np.power(n, 5) + + 38.0 * np.power(n, 6) + ) + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + + ( + 4.0 + * ( + 32.0 + + 240.0 * n + + 496.0 * np.power(n, 2) + - 72.0 * np.power(n, 3) + - 1254.0 * np.power(n, 4) + + 339.0 * np.power(n, 5) + + 6106.0 * np.power(n, 6) + + 11692.0 * np.power(n, 7) + + 13272.0 * np.power(n, 8) + + 10762.0 * np.power(n, 9) + + 6049.0 * np.power(n, 10) + + 2139.0 * np.power(n, 11) + + 443.0 * np.power(n, 12) + + 56.0 * np.power(n, 13) + + 4.0 * np.power(n, 14) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 6) + * np.power(1.0 + n, 6) + * np.power(2.0 + n, 3) + ) + + ( + 6.579736267392905 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 + - 10.0 * n + + np.power(n, 2) + + 4.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 8.0 + * (2.0 + n + np.power(n, 2)) + * ( + -12.0 + - 44.0 * n + - 19.0 * np.power(n, 2) + - 11.0 * np.power(n, 3) + - 2.0 * np.power(n, 4) + + 2.0 * np.power(n, 5) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 4) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -4.0 + - 18.0 * n + - 32.0 * np.power(n, 2) + - 5.0 * np.power(n, 3) + + np.power(n, 4) + ) + * np.power(S1, 2) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 + - 20.0 * n + - 8.0 * np.power(n, 2) + + 56.0 * np.power(n, 3) + + 135.0 * np.power(n, 4) + + 102.0 * np.power(n, 5) + + 27.0 * np.power(n, 6) + ) + * S2 + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + + ( + (2.0 + 3.0 * n) + * (2.0 + n + np.power(n, 2)) + * (-2.6666666666666665 * np.power(S1, 3) - 8.0 * S1 * S2) + ) + / ((-1.0 + n) * np.power(n, 3) * (1.0 + n) * (2.0 + n)) + + ( + 32.0 + * (-2.0 - 3.0 * n + np.power(n, 2)) + * (2.0 + n + np.power(n, 2)) + * S21 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 2.6666666666666665 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 + - 22.0 * n + + 43.0 * np.power(n, 2) + + 48.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + * S3 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + 6.410970150184502 * S1 + + 0.6666666666666666 * np.power(S1, 4) + + 1.6449340668482262 * (4.0 * np.power(S1, 2) - 12.0 * S2) + + 4.0 * np.power(S1, 2) * S2 + + 2.0 * np.power(S2, 2) + - 64.0 * S211 + + S1 * (32.0 * S21 + 5.333333333333333 * S3) + + 32.0 * S31 + - 12.0 * S4 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 0.8888888888888888 + * ( + ( + 1.6027425375461255 + * ( + -1072.0 + - 1008.0 * n + - 4120.0 * np.power(n, 2) + - 7320.0 * np.power(n, 3) + - 3299.0 * np.power(n, 4) + - 1487.0 * np.power(n, 5) + - 1089.0 * np.power(n, 6) + - 45.0 * np.power(n, 7) + + 192.0 * np.power(n, 8) + + 48.0 * np.power(n, 9) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 1.3333333333333333 + * ( + -1728.0 + - 13504.0 * n + - 45232.0 * np.power(n, 2) + - 83504.0 * np.power(n, 3) + - 88676.0 * np.power(n, 4) + - 48500.0 * np.power(n, 5) + + 9415.0 * np.power(n, 6) + + 50675.0 * np.power(n, 7) + + 57974.0 * np.power(n, 8) + + 41400.0 * np.power(n, 9) + + 25694.0 * np.power(n, 10) + + 18236.0 * np.power(n, 11) + + 11443.0 * np.power(n, 12) + + 4569.0 * np.power(n, 13) + + 978.0 * np.power(n, 14) + + 88.0 * np.power(n, 15) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 6) + * np.power(1.0 + n, 6) + * np.power(2.0 + n, 4) + ) + - ( + 1.3333333333333333 + * ( + 192.0 + + 256.0 * n + + 176.0 * np.power(n, 2) + + 840.0 * np.power(n, 3) + + 944.0 * np.power(n, 4) + + 490.0 * np.power(n, 5) + + 662.0 * np.power(n, 6) + + 735.0 * np.power(n, 7) + + 363.0 * np.power(n, 8) + + 75.0 * np.power(n, 9) + + 3.0 * np.power(n, 10) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + ( + -0.4444444444444444 + * ( + -8.0 + - 10.0 * n + + np.power(n, 2) + + 4.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * np.power(S1, 3) + ) + / (n * (1.0 + n)) + + 1.6449340668482262 + * ( + ( + 2.0 + * ( + -12.0 + - 28.0 * n + + 21.0 * np.power(n, 2) + + 106.0 * np.power(n, 3) + + 151.0 * np.power(n, 4) + + 108.0 * np.power(n, 5) + + 38.0 * np.power(n, 6) + ) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + - ( + 4.0 + * ( + -8.0 + - 10.0 * n + + np.power(n, 2) + + 4.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * S1 + ) + / (n * (1.0 + n)) + ) + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 1.3333333333333333 + * ( + -1664.0 + - 6240.0 * n + - 12272.0 * np.power(n, 2) + - 16088.0 * np.power(n, 3) + - 11660.0 * np.power(n, 4) + - 3976.0 * np.power(n, 5) + + 1084.0 * np.power(n, 6) + + 3411.0 * np.power(n, 7) + + 2811.0 * np.power(n, 8) + + 1049.0 * np.power(n, 9) + + 153.0 * np.power(n, 10) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + S1 + * ( + ( + 2.6666666666666665 + * ( + 896.0 + + 4672.0 * n + + 10880.0 * np.power(n, 2) + + 16352.0 * np.power(n, 3) + + 16824.0 * np.power(n, 4) + + 16388.0 * np.power(n, 5) + + 15420.0 * np.power(n, 6) + + 11172.0 * np.power(n, 7) + + 7260.0 * np.power(n, 8) + + 4893.0 * np.power(n, 9) + + 2549.0 * np.power(n, 10) + + 819.0 * np.power(n, 11) + + 151.0 * np.power(n, 12) + + 12.0 * np.power(n, 13) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + - ( + 1.3333333333333333 + * ( + -288.0 + - 904.0 * n + - 844.0 * np.power(n, 2) + - 530.0 * np.power(n, 3) + - 159.0 * np.power(n, 4) + + 229.0 * np.power(n, 5) + + 271.0 * np.power(n, 6) + + 81.0 * np.power(n, 7) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + ) + + ( + 10.666666666666666 + * ( + 88.0 + + 180.0 * n + + 250.0 * np.power(n, 2) + + 283.0 * np.power(n, 3) + + 114.0 * np.power(n, 4) + + 59.0 * np.power(n, 5) + + 84.0 * np.power(n, 6) + + 40.0 * np.power(n, 7) + + 6.0 * np.power(n, 8) + ) + * S21 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 1.7777777777777777 + * ( + 56.0 + + 444.0 * n + - 1074.0 * np.power(n, 2) + - 2859.0 * np.power(n, 3) + - 2063.0 * np.power(n, 4) + - 663.0 * np.power(n, 5) + + 293.0 * np.power(n, 6) + + 478.0 * np.power(n, 7) + + 216.0 * np.power(n, 8) + + 36.0 * np.power(n, 9) + ) + * S3 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + np.power(2.0, 5.0 - 1.0 * n) + * ( + 4.0 + - 2.0 * n + + 10.0 * np.power(n, 2) + - 1.0 * np.power(n, 3) + + np.power(n, 5) + ) + * (8.41439832211716 + H1) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 2)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + 212.26414844076453 + - 0.2222222222222222 * np.power(S1, 4) + + 1.2020569031595942 * (37.333333333333336 * S1 - 448.0 * S1l05) + - 6.666666666666667 * np.power(S1, 2) * S2 + + 15.333333333333334 * np.power(S2, 2) + + 1.6449340668482262 * (-4.0 * np.power(S1, 2) + 12.0 * S2) + + 138.66666666666666 * S211 + + S1 * (-64.0 * S21 + 8.88888888888889 * S3) + + 64.0 * (H2) + + 41.333333333333336 * S4 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 2.0 + * ( + ( + -1.0684950250307503 + * (2.0 + n + np.power(n, 2)) + * ( + -24.0 + - 80.0 * n + - 200.0 * np.power(n, 2) + + 68.0 * np.power(n, 3) + + 75.0 * np.power(n, 4) + + 6.0 * np.power(n, 5) + + 11.0 * np.power(n, 6) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 0.7310818074881006 + * ( + 864.0 + + 4656.0 * n + + 9680.0 * np.power(n, 2) + + 12552.0 * np.power(n, 3) + + 9334.0 * np.power(n, 4) + + 4491.0 * np.power(n, 5) + - 934.0 * np.power(n, 6) + - 1109.0 * np.power(n, 7) + + 2196.0 * np.power(n, 8) + + 2251.0 * np.power(n, 9) + + 820.0 * np.power(n, 10) + + 127.0 * np.power(n, 11) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 2.6666666666666665 + * ( + 384.0 + + 3584.0 * n + + 14816.0 * np.power(n, 2) + + 34528.0 * np.power(n, 3) + + 46456.0 * np.power(n, 4) + + 32640.0 * np.power(n, 5) + + 5554.0 * np.power(n, 6) + - 11770.0 * np.power(n, 7) + - 27469.0 * np.power(n, 8) + - 36527.0 * np.power(n, 9) + - 17182.0 * np.power(n, 10) + + 11176.0 * np.power(n, 11) + + 19051.0 * np.power(n, 12) + + 11527.0 * np.power(n, 13) + + 4188.0 * np.power(n, 14) + + 1030.0 * np.power(n, 15) + + 162.0 * np.power(n, 16) + + 12.0 * np.power(n, 17) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 6) + * np.power(1.0 + n, 6) + * np.power(2.0 + n, 5) + ) + - ( + 2.193245422464302 + * (2.0 + n + np.power(n, 2)) + * ( + -24.0 + - 80.0 * n + - 20.0 * np.power(n, 2) + + 149.0 * np.power(n, 3) + + 75.0 * np.power(n, 4) + + 27.0 * np.power(n, 5) + + 17.0 * np.power(n, 6) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 8.0 + * (2.0 + n + np.power(n, 2)) + * ( + 32.0 + + 72.0 * n + + 396.0 * np.power(n, 2) + + 810.0 * np.power(n, 3) + + 759.0 * np.power(n, 4) + + 386.0 * np.power(n, 5) + + 117.0 * np.power(n, 6) + + 22.0 * np.power(n, 7) + + 2.0 * np.power(n, 8) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + + ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 + + 16.0 * n + + 18.0 * np.power(n, 2) + + 4.0 * np.power(n, 3) + + 7.0 * np.power(n, 4) + + 6.0 * np.power(n, 5) + + np.power(n, 6) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 2.6666666666666665 + * (2.0 + n + np.power(n, 2)) + * (2.0 + 11.0 * n + 8.0 * np.power(n, 2) + np.power(n, 3)) + * np.power(S1, 3) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 1.3333333333333333 + * ( + 384.0 + + 2432.0 * n + + 6512.0 * np.power(n, 2) + + 9608.0 * np.power(n, 3) + + 8076.0 * np.power(n, 4) + + 3318.0 * np.power(n, 5) + - 2510.0 * np.power(n, 6) + - 3801.0 * np.power(n, 7) + - 1152.0 * np.power(n, 8) + + 104.0 * np.power(n, 9) + + 66.0 * np.power(n, 10) + + 3.0 * np.power(n, 11) + ) + * S2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 8.0 + * (2.0 + n + np.power(n, 2)) + * (-2.0 - 27.0 * n - 12.0 * np.power(n, 2) + 3.0 * np.power(n, 3)) + * S1 + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 5.333333333333333 + * (2.0 + n + np.power(n, 2)) + * ( + -24.0 + - 72.0 * n + - 56.0 * np.power(n, 2) + - 25.0 * np.power(n, 3) + - 7.0 * np.power(n, 4) + + 29.0 * np.power(n, 5) + + 11.0 * np.power(n, 6) + ) + * S3 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + 20.0 + + 22.0 * n + + 7.0 * np.power(n, 2) + + 2.0 * np.power(n, 3) + + np.power(n, 4) + ) + * (26.31894506957162 + 32.0 * Sm2) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + ( + (-4.0 - 1.0 * n + np.power(n, 2)) + * (2.0 + n + np.power(n, 2)) + * ( + -28.849365675830263 + - 52.63789013914324 * S1 + - 64.0 * S1 * Sm2 + + 64.0 * Sm21 + - 32.0 * Sm3 + ) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + -6.410970150184502 * S1 + - 0.6666666666666666 * np.power(S1, 4) + - 20.0 * np.power(S1, 2) * S2 + - 2.0 * np.power(S2, 2) + + 16.0 * S211 + + 16.0 * S31 + - 36.0 * S4 + + 1.6449340668482262 + * (-4.0 * np.power(S1, 2) - 12.0 * S2 - 24.0 * Sm2) + + (-32.0 * np.power(S1, 2) - 32.0 * S2) * Sm2 + + S1 * (-53.333333333333336 * S3 + 64.0 * Sm21) + - 64.0 * Sm211 + + 32.0 * Sm22 + - 32.0 * S1 * Sm3 + + 32.0 * Sm31 + - 16.0 * Sm4 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 2.0 + * ( + ( + -1.0684950250307503 + * ( + 1032.0 + + 260.0 * n + + 1098.0 * np.power(n, 2) + - 837.0 * np.power(n, 3) + - 5661.0 * np.power(n, 4) + - 472.0 * np.power(n, 5) + + 1135.0 * np.power(n, 6) + - 367.0 * np.power(n, 7) + - 229.0 * np.power(n, 8) + + 9.0 * np.power(n, 10) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 0.7310818074881006 + * ( + 864.0 + + 4656.0 * n + + 9680.0 * np.power(n, 2) + + 11112.0 * np.power(n, 3) + + 8470.0 * np.power(n, 4) + + 4779.0 * np.power(n, 5) + - 106.0 * np.power(n, 6) + - 317.0 * np.power(n, 7) + + 2484.0 * np.power(n, 8) + + 2323.0 * np.power(n, 9) + + 856.0 * np.power(n, 10) + + 127.0 * np.power(n, 11) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 0.03292181069958848 + * ( + 155520.0 + + 1.308096e6 * n + + 4.812768e6 * np.power(n, 2) + + 1.012152e7 * np.power(n, 3) + + 1.3312808e7 * np.power(n, 4) + + 1.2149124e7 * np.power(n, 5) + + 9.141018e6 * np.power(n, 6) + + 6.186057e6 * np.power(n, 7) + + 1.320584e6 * np.power(n, 8) + - 3.045065e6 * np.power(n, 9) + - 2.526162e6 * np.power(n, 10) + + 374900.0 * np.power(n, 11) + + 1.654143e6 * np.power(n, 12) + + 1.331937e6 * np.power(n, 13) + + 671488.0 * np.power(n, 14) + + 218915.0 * np.power(n, 15) + + 40465.0 * np.power(n, 16) + + 3244.0 * np.power(n, 17) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 6) + * np.power(1.0 + n, 6) + * np.power(2.0 + n, 5) + ) + - ( + 0.14814814814814814 + * ( + 1872.0 + + 4512.0 * n + + 3200.0 * np.power(n, 2) + - 6636.0 * np.power(n, 3) + - 14165.0 * np.power(n, 4) + - 12231.0 * np.power(n, 5) + - 4318.0 * np.power(n, 6) + + 1411.0 * np.power(n, 7) + + 1566.0 * np.power(n, 8) + + 406.0 * np.power(n, 9) + + 145.0 * np.power(n, 10) + + 46.0 * np.power(n, 11) + ) + * np.power(S1, 2) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 0.14814814814814814 + * ( + 12240.0 + + 55200.0 * n + + 106112.0 * np.power(n, 2) + + 114180.0 * np.power(n, 3) + + 81499.0 * np.power(n, 4) + + 62901.0 * np.power(n, 5) + + 17000.0 * np.power(n, 6) + - 773.0 * np.power(n, 7) + + 26208.0 * np.power(n, 8) + + 27688.0 * np.power(n, 9) + + 10993.0 * np.power(n, 10) + + 1696.0 * np.power(n, 11) + ) + * S2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + S1 + * ( + ( + 0.04938271604938271 + * ( + 1728.0 + - 22752.0 * n + - 61248.0 * np.power(n, 2) + + 113008.0 * np.power(n, 3) + + 571260.0 * np.power(n, 4) + + 528058.0 * np.power(n, 5) + + 1854.0 * np.power(n, 6) + - 144034.0 * np.power(n, 7) + + 15119.0 * np.power(n, 8) + + 66314.0 * np.power(n, 9) + + 47061.0 * np.power(n, 10) + + 29936.0 * np.power(n, 11) + + 12147.0 * np.power(n, 12) + + 2518.0 * np.power(n, 13) + + 247.0 * np.power(n, 14) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + + ( + 0.4444444444444444 + * ( + -864.0 + - 2560.0 * n + + 516.0 * np.power(n, 2) + + 1896.0 * np.power(n, 3) + + 3273.0 * np.power(n, 4) + + 2552.0 * np.power(n, 5) + + 1342.0 * np.power(n, 6) + + 1064.0 * np.power(n, 7) + + 269.0 * np.power(n, 8) + ) + * S2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + ) + - ( + 2.6666666666666665 + * ( + 152.0 + + 356.0 * n + + 626.0 * np.power(n, 2) + + 763.0 * np.power(n, 3) + + 194.0 * np.power(n, 4) + - 5.0 * np.power(n, 5) + + 100.0 * np.power(n, 6) + + 48.0 * np.power(n, 7) + + 6.0 * np.power(n, 8) + ) + * S21 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 0.2962962962962963 + * ( + -2136.0 + - 10516.0 * n + - 11598.0 * np.power(n, 2) + - 9939.0 * np.power(n, 3) + - 4923.0 * np.power(n, 4) + + 2618.0 * np.power(n, 5) + + 1345.0 * np.power(n, 6) + + 2039.0 * np.power(n, 7) + + 1745.0 * np.power(n, 8) + + 702.0 * np.power(n, 9) + + 135.0 * np.power(n, 10) + ) + * S3 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + np.power(2.0, 4.0 - 1.0 * n) + * ( + 4.0 + - 2.0 * n + + 10.0 * np.power(n, 2) + - 1.0 * np.power(n, 3) + + np.power(n, 5) + ) + * (-8.41439832211716 - H1) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 2)) + + ( + ( + -2.6666666666666665 + * ( + -416.0 + - 1952.0 * n + - 3680.0 * np.power(n, 2) + - 2096.0 * np.power(n, 3) + - 346.0 * np.power(n, 4) + + 14.0 * np.power(n, 5) + + 259.0 * np.power(n, 6) + + 214.0 * np.power(n, 7) + + 82.0 * np.power(n, 8) + + 44.0 * np.power(n, 9) + + 5.0 * np.power(n, 10) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 10.666666666666666 + * ( + 32.0 + + 120.0 * n + + 104.0 * np.power(n, 2) + + 154.0 * np.power(n, 3) + + 122.0 * np.power(n, 4) + + 49.0 * np.power(n, 5) + + 24.0 * np.power(n, 6) + + 3.0 * np.power(n, 7) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + ) + * Sm2 + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + -184.0593470475842 + + 0.2222222222222222 * np.power(S1, 4) + + 269.2607463077491 * S1l05 + + 22.666666666666668 * np.power(S1, 2) * S2 + - 26.666666666666668 * S211 + + 32.0 * (-H2) + + 37.333333333333336 * np.power(S1, 2) * Sm2 + + 1.6449340668482262 + * (4.0 * np.power(S1, 2) + 12.0 * S2 + 24.0 * Sm2) + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 5.333333333333333 + * ( + -80.0 + - 264.0 * n + - 248.0 * np.power(n, 2) + - 338.0 * np.power(n, 3) + - 293.0 * np.power(n, 4) + - 91.0 * np.power(n, 5) + + 76.0 * np.power(n, 6) + + 105.0 * np.power(n, 7) + + 39.0 * np.power(n, 8) + + 6.0 * np.power(n, 9) + ) + * Sm21 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 2.6666666666666665 + * ( + 112.0 + + 440.0 * n + + 248.0 * np.power(n, 2) + + 286.0 * np.power(n, 3) + + 147.0 * np.power(n, 4) + + 85.0 * np.power(n, 5) + + 148.0 * np.power(n, 6) + + 89.0 * np.power(n, 7) + + 39.0 * np.power(n, 8) + + 6.0 * np.power(n, 9) + ) + * Sm3 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + -3.205485075092251 * (10.0 + 11.0 * n + 11.0 * np.power(n, 2)) * S1 + + ( + 2.193245422464302 + * ( + -24.0 + - 80.0 * n + + 76.0 * np.power(n, 2) + + 77.0 * np.power(n, 3) + + 27.0 * np.power(n, 4) + + 51.0 * np.power(n, 5) + + 17.0 * np.power(n, 6) + ) + * S1 + ) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + + ( + 0.14814814814814814 + * ( + -24.0 + - 80.0 * n + + 76.0 * np.power(n, 2) + + 77.0 * np.power(n, 3) + + 27.0 * np.power(n, 4) + + 51.0 * np.power(n, 5) + + 17.0 * np.power(n, 6) + ) + * np.power(S1, 3) + ) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + + 0.6666666666666666 + * (74.0 + 29.0 * n + 29.0 * np.power(n, 2)) + * np.power(S2, 2) + - 8.0 * (26.0 + 7.0 * n + 7.0 * np.power(n, 2)) * S31 + + 1.3333333333333333 + * (310.0 + 143.0 * n + 143.0 * np.power(n, 2)) + * S4 + + 21.333333333333332 + * (13.0 + 7.0 * n + 7.0 * np.power(n, 2)) + * S2 + * Sm2 + - 5.333333333333333 + * (-2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + * np.power(Sm2, 2) + + S1 + * ( + 0.8888888888888888 + * (334.0 + 137.0 * n + 137.0 * np.power(n, 2)) + * S3 + - 5.333333333333333 + * (18.0 + 35.0 * n + 35.0 * np.power(n, 2)) + * Sm21 + ) + + 21.333333333333332 + * (2.0 + 13.0 * n + 13.0 * np.power(n, 2)) + * Sm211 + - 64.0 * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) * Sm22 + + 2.6666666666666665 + * (94.0 + 69.0 * n + 69.0 * np.power(n, 2)) + * S1 + * Sm3 + - 10.666666666666666 + * (22.0 + 23.0 * n + 23.0 * np.power(n, 2)) + * Sm31 + + 5.333333333333333 + * (50.0 + 31.0 * n + 31.0 * np.power(n, 2)) + * Sm4 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) + + +# H2 = ( +# - S31l205 +# + S1l05 * S3l2 +# # Expansion of H27 + S1111l20511 + S1111l21051 - S121l2051 - S1l05 * (S111l211 + S12l21) +# + ( +# -0.621442 +# # + 2.51724 / n ** 4 +# # + (328.162 * 2 ** (-2 - n)) / n ** 4 +# # - (44.4671 * 2 ** (-n)) / n ** 4 +# # + 1.5302 / n ** 3 +# # - (75.7296 * 2 ** (-2 - n)) / n ** 3 +# # + (10.2616 * 2 ** (-n)) / n ** 3 +# # + 0.072467 / n ** 2 +# # + (25.2432 * 2 ** (-2 - n)) / n ** 2 +# # - (3.42054 * 2 ** (-n)) / n ** 2 +# + 1.64493 / n +# - (25.2432 * 2 ** (-3 - n)) / n +# + (3.42054 * 2 ** (-1 - n)) / n +# # - (6.75 * (0.577216 + np.log(n))) / n ** 4 +# # + (1.83333 * (0.577216 + np.log(n))) / n ** 3 +# # - (0.5 * (0.577216 + np.log(n))) / n ** 2 +# ) +# # Expansion of - H26 + S1l05 * (S21l21) +# - ( +# 1.5806185221185012 +# # - 0.22916666666666666 / n ** 4 +# # - 0.05555555555555555 / n ** 3 +# # + 0.25 / n ** 2 +# # + ( +# # 2.75 / n ** 4 +# # - 1.1666666666666667 / n ** 3 +# # + 0.5 / n ** 2)* ( +# # 0.5772156649015329 + np.log(n) +# # ) +# ) +# ) diff --git a/tests/test_matching_n3lo.py b/tests/test_matching_n3lo.py index 189282da0..1c614c079 100644 --- a/tests/test_matching_n3lo.py +++ b/tests/test_matching_n3lo.py @@ -64,7 +64,7 @@ def get_s4x(N, sx, smx): return s4x -def test_A_2(): +def test_A_3(): nf = 3 N = 1.0 sx = get_sx(N) @@ -127,11 +127,12 @@ def test_A_2(): np.testing.assert_allclose(aNS3[1, 1], 0) -def test_Bluemlein_2(): +def test_Bluemlein_3(): # Test against Blumlein OME implementation :cite:`Bierenbaum_2009`. # For singlet OME only even moments are available in that code. # Note there is a minus sign in the definition of L. + # pylint: disable=too-many-locals ref_val_gg = { 0: [-440.104, -1377.49, -1683.31, -2006.18, -3293.81], } @@ -177,14 +178,16 @@ def test_Bluemlein_2(): np.testing.assert_allclose( aS3[0, 0], ref_val_gg[L][idx] + ref_val_ggTF2[L][idx], rtol=6e-3 ) - if N != 2: - np.testing.assert_allclose(aS3[0, 1], ref_val_gq[L][idx], rtol=2e-6) + + np.testing.assert_allclose(aS3[0, 1], ref_val_gq[L][idx], rtol=2e-6) np.testing.assert_allclose(aS3[1, 0], ref_val_qg[L][idx], rtol=2e-6) np.testing.assert_allclose( aS3[2, 0], ref_val_Hg[L][idx] + ref_val_Hgstfac[L][idx], rtol=2e-6 ) - # np.testing.assert_allclose(aS3[2, 1], ref_val_Hq[L][idx], rtol=3e-6) + np.testing.assert_allclose( + aS3[2, 1], ref_val_Hq[L][idx], rtol=5e-3, atol=3e-4 + ) # here we have a different convention for (-1)^N, # for even values qqNS is analitically continued @@ -225,3 +228,35 @@ def test_Bluemlein_2(): np.testing.assert_allclose( n3lo.aqqNS.A_qqNS_3(N, sx, smx, s3x, s4x, nf), ref, rtol=3e-2 ) + + +def test_AHq_asymptotic(): + refs = [ + -1.06712, + 0.476901, + -0.771605, + 0.388789, + 0.228768, + 0.114067, + 0.0654939, + 0.0409271, + 0.0270083, + 0.01848, + 0.0129479, + 0.00920106, + ] + Ns = [11.0, 12.0, 13.0, 14.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0] + # refs = [ + # -0.159229, 0.101182, -0.143408, 0.0901927, + # -0.130103, 0.0807537, -0.11879, 0.0725926, -0.109075 + # ] + # Ns = [31.,32.,33.,34.,35.,36.,37.,38.,39.] + nf = 3 + for N, r in zip(Ns, refs): + sx = get_sx(N) + smx = get_smx(N) + s3x = get_s3x(N, sx, smx) + s4x = get_s4x(N, sx, smx) + np.testing.assert_allclose( + n3lo.aHq.A_Hq_3(N, sx, smx, s3x, s4x, nf), r, rtol=5e-3, atol=5e-4 + ) From 97e1d458d1a720f77a82cd6d8a94ac28f99e2947 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 4 Oct 2021 09:45:20 +0200 Subject: [PATCH 44/71] black ome n3lo --- src/eko/matching_conditions/n3lo/aHgstfac.py | 3 ++- src/eko/matching_conditions/n3lo/aHq.py | 3 ++- src/eko/matching_conditions/n3lo/agq.py | 2 +- src/eko/matching_conditions/n3lo/aqqNS.py | 2 +- src/eko/matching_conditions/n3lo/f_functions.py | 2 +- src/eko/matching_conditions/n3lo/h_functions.py | 3 ++- src/eko/matching_conditions/n3lo/s_functions.py | 4 ++-- tests/test_s_functions.py | 1 - 8 files changed, 11 insertions(+), 9 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/aHgstfac.py b/src/eko/matching_conditions/n3lo/aHgstfac.py index 324b785f5..d0c500b8c 100644 --- a/src/eko/matching_conditions/n3lo/aHgstfac.py +++ b/src/eko/matching_conditions/n3lo/aHgstfac.py @@ -1,5 +1,6 @@ # -*- coding: utf-8 -*- -"""This module contains the |OME| aHgstfac, the experssions are taken from :cite:`Bierenbaum_2009`""" +"""This module contains the |OME| aHgstfac, +the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np diff --git a/src/eko/matching_conditions/n3lo/aHq.py b/src/eko/matching_conditions/n3lo/aHq.py index 8de1cd1e5..f21978e22 100644 --- a/src/eko/matching_conditions/n3lo/aHq.py +++ b/src/eko/matching_conditions/n3lo/aHq.py @@ -38,7 +38,8 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals H2 = ( -S31l205 + S1l05 * S3l2 - # Expansion of H27 + S1111l20511 + S1111l21051 - S121l2051 - S1l05 * (S111l211 + S12l21) + # Expansion of: + # H27 + S1111l20511 + S1111l21051 - S121l2051 - S1l05 * (S111l211 + S12l21) + ( -0.621442 + 2.51724 / n ** 4 diff --git a/src/eko/matching_conditions/n3lo/agq.py b/src/eko/matching_conditions/n3lo/agq.py index d89da48bc..9c3f1b0d5 100644 --- a/src/eko/matching_conditions/n3lo/agq.py +++ b/src/eko/matching_conditions/n3lo/agq.py @@ -5,7 +5,7 @@ @nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) -def A_gq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals +def A_gq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] Sm1, Sm2, Sm3, Sm4 = smx[0], smx[1], smx[2], smx[3] S21, S2m1, Sm21, Sm2m1 = s3x[0], s3x[1], s3x[2], s3x[3] diff --git a/src/eko/matching_conditions/n3lo/aqqNS.py b/src/eko/matching_conditions/n3lo/aqqNS.py index 325fc0038..477bd9f9f 100644 --- a/src/eko/matching_conditions/n3lo/aqqNS.py +++ b/src/eko/matching_conditions/n3lo/aqqNS.py @@ -7,7 +7,7 @@ @nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) -def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals +def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] Sm1, Sm2, Sm3, Sm4, Sm5 = smx[0], smx[1], smx[2], smx[3], smx[4] S21, S2m1, Sm21 = s3x[0], s3x[1], s3x[2] diff --git a/src/eko/matching_conditions/n3lo/f_functions.py b/src/eko/matching_conditions/n3lo/f_functions.py index 6f61fe988..3fdcfda8d 100644 --- a/src/eko/matching_conditions/n3lo/f_functions.py +++ b/src/eko/matching_conditions/n3lo/f_functions.py @@ -4,7 +4,7 @@ This module contains some Mellin transfomations for 5th order harmonics sum. Notation refers to :cite:`Bl_mlein_2009` Mellin transform is defined with the convention x^(N). -F19, F20, F21 are not present explictly in the paper +F19, F20, F21 are not present explictly in the paper """ import numba as nb import numpy as np diff --git a/src/eko/matching_conditions/n3lo/h_functions.py b/src/eko/matching_conditions/n3lo/h_functions.py index 95be31c1f..32910cb95 100644 --- a/src/eko/matching_conditions/n3lo/h_functions.py +++ b/src/eko/matching_conditions/n3lo/h_functions.py @@ -1,4 +1,5 @@ # -*- coding: utf-8 -*- +# pylint: disable=too-many-lines """This module contains some Mellin transform used for in the generalized haromonic sums. Mellin transform is defined with the convention x^(n) """ @@ -8,7 +9,7 @@ # @nb.njit("c16(c16,c16)", cache=True) def H21(n, S1): - """Mellin transform of :math:`\int_{1}^{2} (x^(n)-1)(ln(1-x/2))/(x-1)`""" + r"""Mellin transform of :math:`\int_{1}^{2} (x^(n)-1)(ln(1-x/2))/(x-1)`""" return complex( complex(-2.4674011002723395, -2.177586090303602) * (-1.0 + np.power(2.0, n)) - 1.0 diff --git a/src/eko/matching_conditions/n3lo/s_functions.py b/src/eko/matching_conditions/n3lo/s_functions.py index 43cd82f81..6428d2c28 100644 --- a/src/eko/matching_conditions/n3lo/s_functions.py +++ b/src/eko/matching_conditions/n3lo/s_functions.py @@ -5,7 +5,7 @@ """ import numpy as np import numba as nb -import mpmath as mp +import mpmath as mp from eko.anomalous_dimensions import harmonics from . import g_functions as gf @@ -24,7 +24,7 @@ def binomial(x, y): """Binomial coefficient for complex numbers""" # return sp.gamma(x + 1) / (sp.gamma(y + 1) * sp.gamma(x - y + 1)) # more accurate for large numbers. - return complex(1/((x +1) * mp.beta(x-y+1,y+1))) + return complex(1 / ((x + 1) * mp.beta(x - y + 1, y + 1))) @nb.njit("c16(c16)", cache=True) diff --git a/tests/test_s_functions.py b/tests/test_s_functions.py index f936d9ccb..74837cfa7 100644 --- a/tests/test_s_functions.py +++ b/tests/test_s_functions.py @@ -61,7 +61,6 @@ def test_Smx(): np.testing.assert_allclose(sm, refvals[f"Sm{i+1}"][j], atol=1e-06) def test_binomial(): - # TODO: is it working for large numbers?? r1 = np.random.randint(1000) r2 = np.random.randint(1000) np.testing.assert_allclose(sf.binomial(r1,r2), sp.binom(r1, r2)) From 7e9782cf64a4872b4c7966e1882fa3d9dd226c99 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 4 Oct 2021 09:48:29 +0200 Subject: [PATCH 45/71] fake N3LO evolution --- src/eko/evolution_operator/__init__.py | 3 ++- src/eko/strong_coupling.py | 5 ++++- tests/test_strong_coupling.py | 2 +- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/eko/evolution_operator/__init__.py b/src/eko/evolution_operator/__init__.py index 568f95a8f..74db534d0 100644 --- a/src/eko/evolution_operator/__init__.py +++ b/src/eko/evolution_operator/__init__.py @@ -317,7 +317,8 @@ def compute(self): 0.5, 1.0 - self._mellin_cut, args=( - self.config["order"], + # TODO: implement N3LO evolution + self.config["order"] if self.config["order"] != 3 else 2, label, self.config["method"], int_disp.log, diff --git a/src/eko/strong_coupling.py b/src/eko/strong_coupling.py index a569cd583..22ed9cdd6 100644 --- a/src/eko/strong_coupling.py +++ b/src/eko/strong_coupling.py @@ -132,9 +132,12 @@ def __init__( raise ValueError(f"alpha_s_ref has to be positive - got {alpha_s_ref}") if scale_ref <= 0: raise ValueError(f"scale_ref has to be positive - got {scale_ref}") - if order not in [0, 1, 2]: + if order not in [0, 1, 2, 3]: raise NotImplementedError("a_s beyond NNLO is not implemented") self.order = order + # TODO: implement a_s running to N3LO + if order == 3: + self.order = self.order -1 if method not in ["expanded", "exact"]: raise ValueError(f"Unknown method {method}") self.method = method diff --git a/tests/test_strong_coupling.py b/tests/test_strong_coupling.py index a5897a1ff..7ab30adc9 100644 --- a/tests/test_strong_coupling.py +++ b/tests/test_strong_coupling.py @@ -83,7 +83,7 @@ def test_init(self): scale_ref, threshold_holder.area_walls[1:-1], (1.0, 1.0, 1.0), - 3, + 4, ) with pytest.raises(ValueError): StrongCoupling( From d86e3968bfb1ee1838ebc06a3cc7b1301ff42528 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 4 Oct 2021 14:19:29 +0200 Subject: [PATCH 46/71] cleaning and more matching log --- backward_paper/evolve_backward.py | 6 +-- src/eko/matching_conditions/n3lo/aHq.py | 38 ------------------- .../operator_matrix_element.py | 1 + src/eko/strong_coupling.py | 2 +- 4 files changed, 5 insertions(+), 42 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index f65d0bca6..b80fe208f 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -29,7 +29,7 @@ class BackwardRunner(BackwardPaperRunner): "kcThr": 1.0, "kbThr": 1.0, "ktThr": 1.0, - "PTO": 2, + "PTO": 3, "IC": 1, "IB": 1, "ModEv": "EXA", @@ -141,8 +141,8 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): # Evolve below c threshold pdf_names = [ - "210629-n3fit-001", # NNLO, fitted charm - "210629-theory-003", # NNLO, perturbative charm + "NNPDF40_nnlo_as_01180", # NNLO, fitted charm + # "210629-theory-003", # NNLO, perturbative charm # "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c # "NNPDF31_nnlo_pch_as_0118" ] diff --git a/src/eko/matching_conditions/n3lo/aHq.py b/src/eko/matching_conditions/n3lo/aHq.py index f21978e22..17aa2ad9b 100644 --- a/src/eko/matching_conditions/n3lo/aHq.py +++ b/src/eko/matching_conditions/n3lo/aHq.py @@ -1532,41 +1532,3 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) ) ) - - -# H2 = ( -# - S31l205 -# + S1l05 * S3l2 -# # Expansion of H27 + S1111l20511 + S1111l21051 - S121l2051 - S1l05 * (S111l211 + S12l21) -# + ( -# -0.621442 -# # + 2.51724 / n ** 4 -# # + (328.162 * 2 ** (-2 - n)) / n ** 4 -# # - (44.4671 * 2 ** (-n)) / n ** 4 -# # + 1.5302 / n ** 3 -# # - (75.7296 * 2 ** (-2 - n)) / n ** 3 -# # + (10.2616 * 2 ** (-n)) / n ** 3 -# # + 0.072467 / n ** 2 -# # + (25.2432 * 2 ** (-2 - n)) / n ** 2 -# # - (3.42054 * 2 ** (-n)) / n ** 2 -# + 1.64493 / n -# - (25.2432 * 2 ** (-3 - n)) / n -# + (3.42054 * 2 ** (-1 - n)) / n -# # - (6.75 * (0.577216 + np.log(n))) / n ** 4 -# # + (1.83333 * (0.577216 + np.log(n))) / n ** 3 -# # - (0.5 * (0.577216 + np.log(n))) / n ** 2 -# ) -# # Expansion of - H26 + S1l05 * (S21l21) -# - ( -# 1.5806185221185012 -# # - 0.22916666666666666 / n ** 4 -# # - 0.05555555555555555 / n ** 3 -# # + 0.25 / n ** 2 -# # + ( -# # 2.75 / n ** 4 -# # - 1.1666666666666667 / n ** 3 -# # + 0.5 / n ** 2)* ( -# # 0.5772156649015329 + np.log(n) -# # ) -# ) -# ) diff --git a/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index f61874376..05e6e1d8f 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -363,6 +363,7 @@ def compute(self, q2, nf, L): continue # iterate sectors for label in labels: + logger.info("Matching: computing entry %s", label) # compute and set res = integrate.quad( quad_ker, diff --git a/src/eko/strong_coupling.py b/src/eko/strong_coupling.py index 22ed9cdd6..3cfedc0b6 100644 --- a/src/eko/strong_coupling.py +++ b/src/eko/strong_coupling.py @@ -133,7 +133,7 @@ def __init__( if scale_ref <= 0: raise ValueError(f"scale_ref has to be positive - got {scale_ref}") if order not in [0, 1, 2, 3]: - raise NotImplementedError("a_s beyond NNLO is not implemented") + raise NotImplementedError("a_s beyond N3LO is not implemented") self.order = order # TODO: implement a_s running to N3LO if order == 3: From 8c6a2564d35e8af9edda7aedab04bcefde13b682 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 5 Oct 2021 15:16:53 +0200 Subject: [PATCH 47/71] Adding doc string to s functions and n3lo init --- src/eko/matching_conditions/n3lo/__init__.py | 49 ++ .../matching_conditions/n3lo/s_functions.py | 597 +++++++++++++++++- 2 files changed, 643 insertions(+), 3 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/__init__.py b/src/eko/matching_conditions/n3lo/__init__.py index a2c8e9739..c030d2c4a 100644 --- a/src/eko/matching_conditions/n3lo/__init__.py +++ b/src/eko/matching_conditions/n3lo/__init__.py @@ -16,6 +16,29 @@ # @nb.njit("c16[:,:](c16,c16[:],u4)", cache=True) def A_singlet_3(n, sx_all, nf): + r""" + Computes the |N3LO| singlet |OME|. + + .. math:: + A^{S,(3)} = \left(\begin{array}{cc} + A_{gg, H}^{S,(3)} & A_{gq, H}^{S,(3)} & 0 + A_{qg, H}^{S,(3)} & A_{qq,H}^{NS,(3)} + A_{qq,H}^{PS,(3)} & 0\\ + A_{hg}^{S,(3)} & A_{hq}^{PS,(3)} & 0\\ + \end{array}\right) + + Parameters + ---------- + n : complex + Mellin moment + sx_all : numpy.ndarray + List of harmonic sums containing: + [S1 ... S5, Sm1 ... Sm5, S21, S2m1, Sm21, Sm2m1, S31, S221, Sm22, Sm211, Sm31] + + Returns + ------- + A_S_3 : numpy.ndarray + |NNLO| singlet |OME| :math:`A^{S,(3)}(N)` + """ sx = sx_all[:5] smx = sx_all[5:10] s3x = sx_all[10:14] @@ -39,6 +62,32 @@ def A_singlet_3(n, sx_all, nf): # @nb.njit("c16[:,:](c16,c16[:],u4)", cache=True) def A_ns_3(n, sx_all, nf): + r""" + Computes the |N3LO| non-singlet |OME|. + + .. math:: + A^{NS,(3)} = \left(\begin{array}{cc} + A_{qq,H}^{NS,(3)} & 0\\ + 0 & 0\\ + \end{array}\right) + + Parameters + ---------- + n : complex + Mellin moment + sx_all : numpy.ndarray + List of harmonic sums containing: + [S1 ... S5, Sm1 ... Sm5, S21, S2m1, Sm21, Sm2m1, S31, S221, Sm22, Sm211, Sm31] + + Returns + ------- + A_NS_3 : numpy.ndarray + |N3LO| non-singlet |OME| :math:`A^{NS,(3)}` + + See Also + -------- + A_qqNS_3 : :math:`A_{qq,H}^{NS,(3))}` + """ sx = sx_all[:5] smx = sx_all[5:10] s3x = sx_all[10:14] diff --git a/src/eko/matching_conditions/n3lo/s_functions.py b/src/eko/matching_conditions/n3lo/s_functions.py index 6428d2c28..072e7df5f 100644 --- a/src/eko/matching_conditions/n3lo/s_functions.py +++ b/src/eko/matching_conditions/n3lo/s_functions.py @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- """ This module contains some additional harmonics sum. -Defintion are coming from :cite:`MuselliPhD,Bl_mlein_2009` +Defintion are coming from :cite:`MuselliPhD,Bl_mlein_2000,Bl_mlein_2009` """ import numpy as np import numba as nb @@ -21,7 +21,20 @@ # @nb.njit("c16(c16,c16)", cache=True) def binomial(x, y): - """Binomial coefficient for complex numbers""" + r""" + Binomial coefficient for complex numbers + + Parameters + ---------- + x : complex + y : complex + + Returns + ------- + ..math:: + \left(\begin{array}{c} x y \end{array}\right) = + \frac{1}{(x+1) Beta(x-y+1,y+1)} + """ # return sp.gamma(x + 1) / (sp.gamma(y + 1) * sp.gamma(x - y + 1)) # more accurate for large numbers. return complex(1 / ((x + 1) * mp.beta(x - y + 1, y + 1))) @@ -29,6 +42,26 @@ def binomial(x, y): @nb.njit("c16(c16)", cache=True) def harmonic_Sm1(N): + r""" + Analytic continuation of harmonic sum :math:`S_{-1}(N)`. + + .. math:: + S_{-1}(N) = \sum\limits_{j=1}^N \frac (-1)^j j + + Parameters + ---------- + N : complex + Mellin moment + + Returns + ------- + Sm1 : complex + Harmonic sum :math:`S_{-1}(N)` + + See Also + -------- + eko.anomalous_dimension.harmonics.harmonic_S1 : :math:`S_1(N)` + """ return (-1) ** N / 2 * ( harmonics.harmonic_S1(N / 2) - harmonics.harmonic_S1((N - 1) / 2) ) - log2 @@ -36,6 +69,26 @@ def harmonic_Sm1(N): @nb.njit("c16(c16)", cache=True) def harmonic_Sm2(N): + r""" + Analytic continuation of harmonic sum :math:`S_{-2}(N)`. + + .. math:: + S_{-2}(N) = \sum\limits_{j=1}^N \frac (-1)^j j^2 + + Parameters + ---------- + N : complex + Mellin moment + + Returns + ------- + Sm2 : complex + Harmonic sum :math:`S_{-2}(N)` + + See Also + -------- + eko.anomalous_dimension.harmonics.harmonic_S2 : :math:`S_2(N)` + """ return (-1) ** N / 4 * ( harmonics.harmonic_S2(N / 2) - harmonics.harmonic_S2((N - 1) / 2) ) - zeta2 / 2 @@ -43,6 +96,26 @@ def harmonic_Sm2(N): @nb.njit("c16(c16)", cache=True) def harmonic_Sm3(N): + r""" + Analytic continuation of harmonic sum :math:`S_{-3}(N)`. + + .. math:: + S_{-3}(N) = \sum\limits_{j=1}^N \frac (-1)^j j^3 + + Parameters + ---------- + N : complex + Mellin moment + + Returns + ------- + Sm3 : complex + Harmonic sum :math:`S_{-3}(N)` + + See Also + -------- + eko.anomalous_dimension.harmonics.harmonic_S3 : :math:`S_3(N)` + """ return (-1) ** N / 8 * ( harmonics.harmonic_S3(N / 2) - harmonics.harmonic_S3((N - 1) / 2) ) - 3 / 4 * zeta3 @@ -50,6 +123,26 @@ def harmonic_Sm3(N): @nb.njit("c16(c16)", cache=True) def harmonic_Sm4(N): + r""" + Analytic continuation of harmonic sum :math:`S_{-4}(N)`. + + .. math:: + S_{-4}(N) = \sum\limits_{j=1}^N \frac (-1)^j j^4 + + Parameters + ---------- + N : complex + Mellin moment + + Returns + ------- + Sm4 : complex + Harmonic sum :math:`S_{-4}(N)` + + See Also + -------- + eko.anomalous_dimension.harmonics.harmonic_S4 : :math:`S_4(N)` + """ return (-1) ** N / 16 * ( harmonics.harmonic_S4(N / 2) - harmonics.harmonic_S4((N - 1) / 2) ) - 7 / 8 * zeta4 @@ -57,6 +150,26 @@ def harmonic_Sm4(N): @nb.njit("c16(c16)", cache=True) def harmonic_Sm5(N): + r""" + Analytic continuation of harmonic sum :math:`S_{-5}(N)`. + + .. math:: + S_{-5}(N) = \sum\limits_{j=1}^N \frac (-1)^j j^5 + + Parameters + ---------- + N : complex + Mellin moment + + Returns + ------- + Sm5 : complex + Harmonic sum :math:`S_{-5}(N)` + + See Also + -------- + eko.anomalous_dimension.harmonics.harmonic_S5 : :math:`S_5(N)` + """ return (-1) ** N / 32 * ( harmonics.harmonic_S5(N / 2) - harmonics.harmonic_S5((N - 1) / 2) ) - 15 / 16 * zeta5 @@ -64,12 +177,54 @@ def harmonic_Sm5(N): @nb.njit("c16(c16,c16,c16)", cache=True) def harmonic_S21(N, S1, S2): + r""" + Analytic continuation of harmonic sum :math:`S_{2,1}(N)` + as implemented in eq B.5.77 of :cite:`MuselliPhD`and eq 37 of cite:`Bl_mlein_2000`. + + Parameters + ---------- + N : complex + Mellin moment + S1: complex + Hamrmonic sum :math:`S_{1}(N)` + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + + Returns + ------- + S21 : complex + Harmonic sum :math:`S_{2,1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.g_functions.mellin_g18 : :math:`g_18(N)` + """ return -gf.mellin_g18(N, S1, S2) + 2 * zeta3 @nb.njit("c16(c16,c16)", cache=True) def harmonic_Sm21(N, Sm1): - # Note Mellin G3 was integrated following x^(N-1) convention. + r""" + Analytic continuation of harmonic sum :math:`S_{-2,1}(N)` + as implemented in eq B.5.75 of :cite:`MuselliPhD` and eq 22 of cite:`Bl_mlein_2000`. + + Parameters + ---------- + N : complex + Mellin moment + Sm1: complex + Hamrmonic sum :math:`S_{-1}(N)` + + Returns + ------- + Sm21 : complex + Harmonic sum :math:`S_{-2,1}(N)` + + See Also + -------- + eko.anomalous_dimension.harmonics.melling_g3 : :math:`g_3(N)` + """ + # Note mellin g3 was integrated following x^(N-1) convention. return ( -((-1) ** N) * harmonics.mellin_g3(N + 1) + zeta2 * Sm1 @@ -80,6 +235,30 @@ def harmonic_Sm21(N, Sm1): @nb.njit("c16(c16,c16,c16,c16)", cache=True) def harmonic_S2m1(N, S2, Sm1, Sm2): + r""" + Analytic continuation of harmonic sum :math:`S_{2,-1}(N)` + as implemented in eq B.5.76 of :cite:`MuselliPhD`and eq 23 of cite:`Bl_mlein_2000`. + + Parameters + ---------- + N : complex + Mellin moment + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + Sm1: complex + Hamrmonic sum :math:`S_{-1}(N)` + Sm2: complex + Hamrmonic sum :math:`S_{-2}(N)` + + Returns + ------- + S2m1 : complex + Harmonic sum :math:`S_{2,-1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.g_functions.mellin_g4 : :math:`g_4(N)` + """ return ( -((-1) ** N) * gf.mellin_g4(N) - np.log(2) * (S2 - Sm2) @@ -91,6 +270,28 @@ def harmonic_S2m1(N, S2, Sm1, Sm2): @nb.njit("c16(c16,c16,c16)", cache=True) def harmonic_Sm31(N, Sm1, Sm2): + r""" + Analytic continuation of harmonic sum :math:`S_{-3,1}(N)` + as implemented in eq B.5.93 of :cite:`MuselliPhD`and eq 25 of cite:`Bl_mlein_2000`. + + Parameters + ---------- + N : complex + Mellin moment + Sm1: complex + Hamrmonic sum :math:`S_{-1}(N)` + Sm2: complex + Hamrmonic sum :math:`S_{-2}(N)` + + Returns + ------- + Sm31 : complex + Harmonic sum :math:`S_{-3,1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.g_functions.mellin_g6 : :math:`g_6(N)` + """ return ( (-1) ** N * gf.mellin_g6(N) + zeta2 * Sm2 @@ -105,6 +306,25 @@ def harmonic_Sm31(N, Sm1, Sm2): @nb.njit("c16(c16,c16)", cache=True) def harmonic_Sm22(N, Sm31): + r""" + Analytic continuation of harmonic sum :math:`S_{-2,2}(N)` + as implemented in eq B.5.94 of :cite:`MuselliPhD`and eq 24 of cite:`Bl_mlein_2000`. + + Parameters + ---------- + N : complex + Mellin moment + Sm31: complex + Hamrmonic sum :math:`S_{-3,1}(N)` + Returns + ------- + Sm22 : complex + Harmonic sum :math:`S_{-2,2}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.g_functions.mellin_g5 : :math:`g_5(N)` + """ return ( (-1) ** N * gf.mellin_g5(N) - 2 * Sm31 @@ -115,6 +335,26 @@ def harmonic_Sm22(N, Sm31): @nb.njit("c16(c16,c16)", cache=True) def harmonic_Sm211(N, Sm1): + r""" + Analytic continuation of harmonic sum :math:`S_{-2,1,1}(N)` + as implemented in eq B.5.104 of :cite:`MuselliPhD`and eq 27 of cite:`Bl_mlein_2000`. + + Parameters + ---------- + N : complex + Mellin moment + Sm1: complex + Hamrmonic sum :math:`S_{-1}(N)` + + Returns + ------- + Sm31 : complex + Harmonic sum :math:`S_{-2,1,1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.g_functions.mellin_g8 : :math:`g_8(N)` + """ return ( -((-1) ** N) * gf.mellin_g8(N) + zeta3 * Sm1 @@ -128,16 +368,86 @@ def harmonic_Sm211(N, Sm1): @nb.njit("c16(c16,c16,c16,c16)", cache=True) def harmonic_Sm2m1(N, S1, S2, Sm2): + r""" + Analytic continuation of harmonic sum :math:`S_{-2,-1}(N)` + as implemented in eq B.5.74 of :cite:`MuselliPhD`and eq 38 of cite:`Bl_mlein_2000`. + + Parameters + ---------- + N : complex + Mellin moment + S1: complex + Hamrmonic sum :math:`S_{1}(N)` + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + Sm2: complex + Hamrmonic sum :math:`S_{-2}(N)` + + Returns + ------- + Sm2m1 : complex + Harmonic sum :math:`S_{-2,-1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.g_functions.mellin_g19 : :math:`g_19(N)` + """ return -gf.mellin_g19(N, S1) + log2 * (S2 - Sm2) - 5 / 8 * zeta3 @nb.njit("c16(c16,c16,c16,c16)", cache=True) def harmonic_S211(N, S1, S2, S3): + r""" + Analytic continuation of harmonic sum :math:`S_{2,1,1}(N)` + as implemented in eq B.5.115 of :cite:`MuselliPhD`and eq 40 of cite:`Bl_mlein_2000`. + + Parameters + ---------- + N : complex + Mellin moment + S1: complex + Hamrmonic sum :math:`S_{1}(N)` + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + S3: complex + Hamrmonic sum :math:`S_{3}(N)` + + Returns + ------- + S211 : complex + Harmonic sum :math:`S_{2,1,1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.g_functions.mellin_g21 : :math:`g_21(N)` + """ return -gf.mellin_g21(N, S1, S2, S3) + 6 / 5 * zeta2 ** 2 @nb.njit("c16(c16,c16,c16)", cache=True) def harmonic_S31(N, S2, S4): + r""" + Analytic continuation of harmonic sum :math:`S_{3,1}(N)` + as implemented in eq B.5.99 of :cite:`MuselliPhD`and eq 41 of cite:`Bl_mlein_2000`. + + Parameters + ---------- + N : complex + Mellin moment + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + S4: complex + Hamrmonic sum :math:`S_{4}(N)` + + Returns + ------- + S31 : complex + Harmonic sum :math:`S_{3,1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.g_functions.mellin_g22 : :math:`g_22(N)` + """ return ( 1 / 2 * gf.mellin_g22(N) - 1 / 4 * S4 @@ -149,16 +459,91 @@ def harmonic_S31(N, S2, S4): @nb.njit("c16(c16,c16,c16,c16)", cache=True) def harmonic_S41(N, S1, S2, S3): + r""" + Analytic continuation of harmonic sum :math:`S_{4,1}(N)` + as implemented in eq 9.1 of cite:` Bl_mlein_2009` + + Parameters + ---------- + N : complex + Mellin moment + S1: complex + Hamrmonic sum :math:`S_{1}(N)` + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + S3: complex + Hamrmonic sum :math:`S_{3}(N)` + + Returns + ------- + S41 : complex + Harmonic sum :math:`S_{4,1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.f_functions.F9 : + :math:`\mathcal{M}[(\text{Li}_4(x)/(x-1))_{+}](N)` + """ return -f.F9(N, S1) + S1 * zeta4 - S2 * zeta3 + S3 * zeta2 @nb.njit("c16(c16,c16,c16)", cache=True) def harmonic_S311(N, S1, S2): + r""" + Analytic continuation of harmonic sum :math:`S_{3,1,1}(N)` + as implemented in eq 9.21 of cite:` Bl_mlein_2009` + + Parameters + ---------- + N : complex + Mellin moment + S1: complex + Hamrmonic sum :math:`S_{1}(N)` + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + + Returns + ------- + S311 : complex + Harmonic sum :math:`S_{3,1,1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.f_functions.F11 : + :math:`\mathcal{M}[(\text{S}_{2,2}(x)/(x-1))_{+}](N)` + """ return f.F11(N, S1, S2) + zeta3 * S2 - zeta4 / 4 * S1 @nb.njit("c16(c16,c16,c16,c16)", cache=True) def harmonic_S221(N, S1, S2, S21): + r""" + Analytic continuation of harmonic sum :math:`S_{2,2,1}(N)` + as implemented in eq 9.23 of cite:` Bl_mlein_2009` + + Parameters + ---------- + N : complex + Mellin moment + S1: complex + Hamrmonic sum :math:`S_{1}(N)` + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + S21: complex + Hamrmonic sum :math:`S_{2,1}(N)` + + Returns + ------- + S221 : complex + Harmonic sum :math:`S_{2,2,1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.f_functions.F11 : + :math:`\mathcal{M}[(\text{S}_{2,2}(x)/(x-1))_{+}](N)` + eko.mathcing_conditions.n3lo.f_functions.F13 : + :math:`\mathcal{M}[(\text{Li}_{2}^2(x)/(x-1))_{+}](N)` + """ return ( -2 * f.F11(N, S1, S2) + 1 / 2 * f.F13(N, S1, S2) @@ -169,6 +554,33 @@ def harmonic_S221(N, S1, S2, S21): @nb.njit("c16(c16,c16,c16,c16,c16)", cache=True) def harmonic_Sm221(N, S1, Sm1, S21, Sm21): + r""" + Analytic continuation of harmonic sum :math:`S_{-2,2,1}(N)` + as implemented in eq 9.25 of cite:` Bl_mlein_2009` + + Parameters + ---------- + N : complex + Mellin moment + S1: complex + Hamrmonic sum :math:`S_{1}(N)` + Sm1: complex + Hamrmonic sum :math:`S_{-1}(N)` + S21: complex + Hamrmonic sum :math:`S_{2,1}(N)` + Sm21: complex + Hamrmonic sum :math:`S_{-2,1}(N)` + + Returns + ------- + Sm221 : complex + Harmonic sum :math:`S_{-2,2,1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.f_functions.F14F12 : + :math:`\mathcal{M}[(2 \text{S}_{2,2}(x) - 1/2 \text{Li}_{2}^2(x))/(x+1)](N)` + """ return ( (-1) ** (N + 1) * (f.F14F12(N, S1, S21)) + zeta2 * Sm21 @@ -180,6 +592,43 @@ def harmonic_Sm221(N, S1, Sm1, S21, Sm21): @nb.njit("c16(c16,c16,c16,c16,c16,c16,c16,c16,c16)", cache=True) def harmonic_S21m2(N, S1, S2, Sm1, Sm2, Sm3, S21, Sm21, S2m1): + r""" + Analytic continuation of harmonic sum :math:`S_{2,1,-2}(N)` + as implemented in eq 9.26 of cite:` Bl_mlein_2009` + + Parameters + ---------- + N : complex + Mellin moment + S1: complex + Hamrmonic sum :math:`S_{1}(N)` + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + Sm1: complex + Hamrmonic sum :math:`S_{-1}(N)` + Sm2: complex + Hamrmonic sum :math:`S_{-2}(N)` + Sm3: complex + Hamrmonic sum :math:`S_{-3}(N)` + S21: complex + Hamrmonic sum :math:`S_{2,1}(N)` + Sm21: complex + Hamrmonic sum :math:`S_{-2,1}(N)` + S2m1: complex + Hamrmonic sum :math:`S_{2,-1}(N)` + + Returns + ------- + S21m2 : complex + Harmonic sum :math:`S_{2,1,-2}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.f_functions.F14F12 : + :math:`\mathcal{M}[ + (\text{ln}(x) \text{S}_{1,2}(−x) − \text{Li}_2^2(−x)/2)/(x+1) + ](N)` + """ return ( (-1) ** (N) * f.F16(N, S1, Sm1, Sm2, Sm3, Sm21) - 1 / 2 * zeta2 * (S21 - S2m1) @@ -191,11 +640,63 @@ def harmonic_S21m2(N, S1, S2, Sm1, Sm2, Sm3, S21, Sm21, S2m1): @nb.njit("c16(c16,c16,c16,c16)", cache=True) def harmonic_S2111(N, S1, S2, S3): + r""" + Analytic continuation of harmonic sum :math:`S_{2,1,1,1}(N)` + as implemented in eq 9.33 of cite:` Bl_mlein_2009` + + Parameters + ---------- + N : complex + Mellin moment + S1: complex + Hamrmonic sum :math:`S_{1}(N)` + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + S3: complex + Hamrmonic sum :math:`S_{3}(N)` + + Returns + ------- + S2111 : complex + Harmonic sum :math:`S_{2,1,1,1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.f_functions.F17 : + :math:`\mathcal{M}[(\text{S}_{1,3}(x)/(x-1))_{+}](N)` + """ return -f.F17(N, S1, S2, S3) + zeta4 * S1 @nb.njit("c16(c16,c16,c16,c16,c16)", cache=True) def harmonic_Sm2111(N, S1, S2, S3, Sm1): + r""" + Analytic continuation of harmonic sum :math:`S_{-2,1,1,1}(N)` + as implemented in eq 9.34 of cite:` Bl_mlein_2009` + + Parameters + ---------- + N : complex + Mellin moment + S1: complex + Hamrmonic sum :math:`S_{1}(N)` + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + S3: complex + Hamrmonic sum :math:`S_{3}(N)` + Sm1: complex + Hamrmonic sum :math:`S_{-1}(N)` + + Returns + ------- + Sm2111 : complex + Harmonic sum :math:`S_{-2,1,1,1}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.f_functions.F18 : + :math:`\mathcal{M}[\text{S}_{1,3}(x)/(x+1)](N)` + """ return ( (-1) ** (N + 1) * f.F18(N, S1, S2, S3) + zeta4 * Sm1 @@ -206,11 +707,69 @@ def harmonic_Sm2111(N, S1, S2, S3, Sm1): @nb.njit("c16(c16,c16,c16,c16)", cache=True) def harmonic_S23(N, S1, S2, S3): + r""" + Analytic continuation of harmonic sum :math:`S_{2,3}(N)` + as implemented in eq 9.3 of cite:` Bl_mlein_2009` + + Parameters + ---------- + N : complex + Mellin moment + S1: complex + Hamrmonic sum :math:`S_{1}(N)` + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + S3: complex + Hamrmonic sum :math:`S_{3}(N)` + + Returns + ------- + S23 : complex + Harmonic sum :math:`S_{2,3}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.f_functions.F19 : + :math:`\mathcal{M}[ + (( + \text{ln}(x)[\text{S}_{1,2}(1-x) - \zeta_3] + +3 [\text{S}_{1,3}(1-x) - \zeta_4] + /(x-1))_{+}](N)` + """ return f.F19(N, S1, S2, S3) + 3 * zeta4 * S1 @nb.njit("c16(c16,c16,c16,c16)", cache=True) def harmonic_Sm23(N, Sm1, Sm2, Sm3): + r""" + Analytic continuation of harmonic sum :math:`S_{-2,3}(N)` + as implemented in eq 9.4 of cite:` Bl_mlein_2009` + + Parameters + ---------- + N : complex + Mellin moment + Sm1: complex + Hamrmonic sum :math:`S_{-1}(N)` + Sm2: complex + Hamrmonic sum :math:`S_{-2}(N)` + Sm3: complex + Hamrmonic sum :math:`S_{-3}(N)` + + Returns + ------- + Sm23 : complex + Harmonic sum :math:`S_{-2,3}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.f_functions.F19 : + :math:`\mathcal{M}[ + ( + \text{ln}(x)[\text{S}_{1,2}(1-x) - \zeta_3] + +3 [\text{S}_{1,3}(1-x) - \zeta_4] + /(x+1)](N)` + """ return ( (-1) ** N * f.F20(N, Sm1, Sm2, Sm3) + 3 * zeta4 * Sm1 @@ -222,6 +781,38 @@ def harmonic_Sm23(N, Sm1, Sm2, Sm3): @nb.njit("c16(c16,c16,c16,c16,c16)", cache=True) def harmonic_S2m3(N, S2, Sm1, Sm2, Sm3): + r""" + Analytic continuation of harmonic sum :math:`S_{2,-3}(N)` + as implemented in eq 9.5 of cite:` Bl_mlein_2009` + + Parameters + ---------- + N : complex + Mellin moment + S2: complex + Hamrmonic sum :math:`S_{2}(N)` + Sm1: complex + Hamrmonic sum :math:`S_{-1}(N)` + Sm2: complex + Hamrmonic sum :math:`S_{-2}(N)` + Sm3: complex + Hamrmonic sum :math:`S_{-3}(N)` + + Returns + ------- + S2m3 : complex + Harmonic sum :math:`S_{2,-3}(N)` + + See Also + -------- + eko.mathcing_conditions.n3lo.f_functions.F19 : + :math:`\mathcal{M}[ + (( + 1/2 \text{ln}^2(x) \text{Li}_2(-x) + -2 \text{ln}(x) \text{Li}_3(-x) + +3 \text{Li}_4(-x) + )/(x-1)](N)` + """ return ( (-1) ** (N + 1) * f.F21(N, Sm1, Sm2, Sm3) + 3 / 4 * zeta3 * (Sm2 - S2) From c9b7b2eab890529e6ebd54e9f5d182660e7732ab Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 5 Oct 2021 18:49:27 +0200 Subject: [PATCH 48/71] Adding docs to N3LO matching contions --- doc/source/refs.bib | 46 ++++++++++++++++++++ src/eko/matching_conditions/n3lo/aHg.py | 29 +++++++++++- src/eko/matching_conditions/n3lo/aHgstfac.py | 20 ++++++++- src/eko/matching_conditions/n3lo/aHq.py | 29 +++++++++++- src/eko/matching_conditions/n3lo/agg.py | 30 ++++++++++++- src/eko/matching_conditions/n3lo/aggTF2.py | 25 +++++++++-- src/eko/matching_conditions/n3lo/agq.py | 25 ++++++++++- src/eko/matching_conditions/n3lo/aqg.py | 25 ++++++++++- src/eko/matching_conditions/n3lo/aqqNS.py | 27 +++++++++++- src/eko/matching_conditions/n3lo/aqqPS.py | 19 +++++++- 10 files changed, 262 insertions(+), 13 deletions(-) diff --git a/doc/source/refs.bib b/doc/source/refs.bib index 8f327ea8b..7427f80a0 100644 --- a/doc/source/refs.bib +++ b/doc/source/refs.bib @@ -402,3 +402,49 @@ @article{Bl_mlein_2009 month={Nov}, pages={2218–2249} } + +@misc{ablinger2017heavy, + title={Heavy Flavor Wilson Coefficients in Deep-Inelastic Scattering: Recent Results}, + author={J. Ablinger and A. Behring and J. Blümlein and A. De Freitas and A. von Manteuffel and C. Schneider}, + year={2017}, + eprint={1711.07957}, + archivePrefix={arXiv}, + primaryClass={hep-ph} +} + +@misc{ablinger20143loop, + title={3-loop Massive $O(T_F^2)$ Contributions to the DIS Operator Matrix Element $A_{gg}$}, + author={J. Ablinger and J. Blümlein and A. De Freitas and A. Hasselhuhn and A. von Manteuffel and M. Round and C. Schneider}, + year={2014}, + eprint={1409.1435}, + archivePrefix={arXiv}, + primaryClass={hep-ph} +} + +@article{Ablinger_2014, + title={The transition matrix element Agq(N) of the variable flavor number scheme at O(αs3)}, + volume={882}, + ISSN={0550-3213}, + url={http://dx.doi.org/10.1016/j.nuclphysb.2014.02.007}, + DOI={10.1016/j.nuclphysb.2014.02.007}, + journal={Nuclear Physics B}, + publisher={Elsevier BV}, + author={Ablinger, J. and Blümlein, J. and De Freitas, A. and Hasselhuhn, A. and von Manteuffel, A. and Round, M. and Schneider, C. and Wißbrock, F.}, + year={2014}, + month={May}, + pages={263–288} +} + +@article{Ablinger_2015, + title={The 3-loop pure singlet heavy flavor contributions to the structure functionF2(x,Q2)and the anomalous dimension}, + volume={890}, + ISSN={0550-3213}, + url={http://dx.doi.org/10.1016/j.nuclphysb.2014.10.008}, + DOI={10.1016/j.nuclphysb.2014.10.008}, + journal={Nuclear Physics B}, + publisher={Elsevier BV}, + author={Ablinger, J. and Behring, A. and Blümlein, J. and De Freitas, A. and von Manteuffel, A. and Schneider, C.}, + year={2015}, + month={Jan}, + pages={48–151} +} \ No newline at end of file diff --git a/src/eko/matching_conditions/n3lo/aHg.py b/src/eko/matching_conditions/n3lo/aHg.py index 504d54c4f..17d8e8f9f 100644 --- a/src/eko/matching_conditions/n3lo/aHg.py +++ b/src/eko/matching_conditions/n3lo/aHg.py @@ -1,6 +1,5 @@ # -*- coding: utf-8 -*- # pylint: disable=too-many-lines -"""This module contains the |OME| aHg, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np @@ -9,6 +8,34 @@ @nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) def A_Hg_3(n, sx, smx, s3x, s4x, nf): + r""" + Computes the |N3LO| singlet |OME| :math:`A_{Hg}^{S,(3)}(N)`. + The experssion is presented in :cite:`Bierenbaum_2009` + + Parameters + ---------- + n : complex + Mellin moment + sx : numpy.ndarray + list S1 ... S5 + smx : numpy.ndarray + list Sm1 ... Sm5 + s3x : numpy.ndarray + list S21, S2m1, Sm21, Sm2m1 + s4x : numpy.ndarray + list S31, S221, Sm22, Sm211, Sm31 + nf : int + numeber of active flavor below the threshold + + Returns + ------- + A_Hg_3 : complex + :math:`A_{Hg}^{S,(3)}(N)` + See Also + -------- + A_Hgstfac_3: eko.matching_conditions.n3lo.aHgstfac.A_Hgstfac_3 + Incomplete part of the |OME|. + """ S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] S21, Sm21 = s3x[0], s3x[2] diff --git a/src/eko/matching_conditions/n3lo/aHgstfac.py b/src/eko/matching_conditions/n3lo/aHgstfac.py index d0c500b8c..c69b03cdd 100644 --- a/src/eko/matching_conditions/n3lo/aHgstfac.py +++ b/src/eko/matching_conditions/n3lo/aHgstfac.py @@ -1,12 +1,28 @@ # -*- coding: utf-8 -*- -"""This module contains the |OME| aHgstfac, -the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np @nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) def A_Hgstfac_3(n, sx, smx, s3x, s4x, nf): + r""" + Computes the approximate incomplete part of :math:`A_{Hg}^{S,(3)}(N)` + proportional to various color factors. + The experssion is presented in cite:`ablinger2017heavy` (eq 3.1) + + Parameters + ---------- + n : complex + Mellin moment + sx : numpy.ndarray + list S1 ... S5 + s3x : numpy.ndarray + list S21, S2m1, Sm21, Sm2m1 + + Returns + ------- + A_ggTF2_3 : complex + """ S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] S21, Sm21 = s3x[0], s3x[2] diff --git a/src/eko/matching_conditions/n3lo/aHq.py b/src/eko/matching_conditions/n3lo/aHq.py index 17aa2ad9b..4d14d2c31 100644 --- a/src/eko/matching_conditions/n3lo/aHq.py +++ b/src/eko/matching_conditions/n3lo/aHq.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # pylint: disable=too-many-lines -"""This module contains the |OME| aHq, the experssions are taken from :cite:`Bierenbaum_2009`""" +"""This module contains the |OME| aHq, the experssions are taken from """ import numpy as np from . import cs_functions as cs @@ -8,6 +8,33 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals + r""" + Computes the |N3LO| singlet |OME| :math:`A_{Hq}^{S,(3)}(N)`. + The experssion is presented in :cite:`Ablinger_2015` (eq 5.1). + It contains generalized harmonics sums, which are computed inside + :ref:`eko.matching_conditions.n3lo.cs_functions` and use the libary + mpmath which is not compatible with numba. + + Parameters + ---------- + n : complex + Mellin moment + sx : numpy.ndarray + list S1 ... S5 + smx : numpy.ndarray + list Sm1 ... Sm5 + s3x : numpy.ndarray + list S21, S2m1, Sm21, Sm2m1 + s4x : numpy.ndarray + list S31, S221, Sm22, Sm211, Sm31 + nf : int + numeber of active flavor below the threshold + + Returns + ------- + A_Hq_3 : complex + :math:`A_{Hq}^{S,(3)}(N)` + """ S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] S21, Sm21 = s3x[0], s3x[2] diff --git a/src/eko/matching_conditions/n3lo/agg.py b/src/eko/matching_conditions/n3lo/agg.py index e961c1fb2..6adc7fad1 100644 --- a/src/eko/matching_conditions/n3lo/agg.py +++ b/src/eko/matching_conditions/n3lo/agg.py @@ -1,11 +1,39 @@ # -*- coding: utf-8 -*- -"""This module contains the |OME| agg, the experssions are taken from :cite:`Bierenbaum_2009`""" import numpy as np from .aggTF2 import A_ggTF2_3 def A_gg_3(n, sx, smx, s3x, s4x, nf): + r""" + Computes the |N3LO| singlet |OME| :math:`A_{gg}^{S,(3)}(N)`. + The experssion is presented in :cite:`Bierenbaum_2009` + + Parameters + ---------- + n : complex + Mellin moment + sx : numpy.ndarray + list S1 ... S5 + smx : numpy.ndarray + list Sm1 ... Sm5 + s3x : numpy.ndarray + list S21, S2m1, Sm21, Sm2m1 + s4x : numpy.ndarray + list S31, S221, Sm22, Sm211, Sm31 + nf : int + numeber of active flavor below the threshold + + Returns + ------- + A_gg_3 : complex + :math:`A_{gg}^{S,(3)}(N)` + + See Also + -------- + A_ggTF2_3: eko.matching_conditions.n3lo.aggTF2.A_ggTF2_3 + Incomplete part proportional to :math:`T_{F}^2`. + """ S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] S21, Sm21 = s3x[0], s3x[2] diff --git a/src/eko/matching_conditions/n3lo/aggTF2.py b/src/eko/matching_conditions/n3lo/aggTF2.py index acef7ac8f..230054d03 100644 --- a/src/eko/matching_conditions/n3lo/aggTF2.py +++ b/src/eko/matching_conditions/n3lo/aggTF2.py @@ -1,14 +1,31 @@ # -*- coding: utf-8 -*- -""" -This module contains the inclomplete |OME| aggTF2, -the experssions are taken from :cite:`Bierenbaum_2009` -""" import numpy as np from .s_functions import binomial def A_ggTF2_3(n, sx, s3x): + r""" + Computes the approximate incomplete part of :math:`A_{gg}^{S,(3)}(N)` + prortional to :math:`T_{F}^2`. + The experssion is presented in :cite:`ablinger20143loop` (eq 13). + It contains a binomial factor which is computed with mpmath and + is not comaptible with numba. + + Parameters + ---------- + n : complex + Mellin moment + sx : numpy.ndarray + list S1 ... S5 + s3x : numpy.ndarray + list S21, S2m1, Sm21, Sm2m1 + + Returns + ------- + A_ggTF2_3 : complex + :math:`A_{gg,T_{F}^2}^{S,(3)}(N)` + """ S1, S2, S3 = sx[0], sx[1], sx[2] S21 = s3x[0] binfact = binomial(2 * n, n) / 4 ** n diff --git a/src/eko/matching_conditions/n3lo/agq.py b/src/eko/matching_conditions/n3lo/agq.py index 9c3f1b0d5..8b005a95e 100644 --- a/src/eko/matching_conditions/n3lo/agq.py +++ b/src/eko/matching_conditions/n3lo/agq.py @@ -1,11 +1,34 @@ # -*- coding: utf-8 -*- -"""This module contains the |OME| agq, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np @nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) def A_gq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals + r""" + Computes the |N3LO| singlet |OME| :math:`A_{gq}^{S,(3)}(N)`. + The experssion is presented in :cite:`Ablinger_2014` (eq 6.3) + + Parameters + ---------- + n : complex + Mellin moment + sx : numpy.ndarray + list S1 ... S5 + smx : numpy.ndarray + list Sm1 ... Sm5 + s3x : numpy.ndarray + list S21, S2m1, Sm21, Sm2m1 + s4x : numpy.ndarray + list S31, S221, Sm22, Sm211, Sm31 + nf : int + numeber of active flavor below the threshold + + Returns + ------- + A_gq_3 : complex + :math:`A_{gq}^{S,(3)}(N)` + """ S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] Sm1, Sm2, Sm3, Sm4 = smx[0], smx[1], smx[2], smx[3] S21, S2m1, Sm21, Sm2m1 = s3x[0], s3x[1], s3x[2], s3x[3] diff --git a/src/eko/matching_conditions/n3lo/aqg.py b/src/eko/matching_conditions/n3lo/aqg.py index 16d60a3fa..24bc99b12 100644 --- a/src/eko/matching_conditions/n3lo/aqg.py +++ b/src/eko/matching_conditions/n3lo/aqg.py @@ -1,11 +1,34 @@ # -*- coding: utf-8 -*- -"""This module contains the |OME| aqg, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np @nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) def A_qg_3(n, sx, smx, s3x, s4x, nf): + r""" + Computes the |N3LO| singlet |OME| :math:`A_{qg}^{S,(3)}(N)`. + The expression is presented in :cite:`Bierenbaum_2009` + + Parameters + ---------- + n : complex + Mellin moment + sx : numpy.ndarray + list S1 ... S5 + smx : numpy.ndarray + list Sm1 ... Sm5 + s3x : numpy.ndarray + list S21, S2m1, Sm21, Sm2m1 + s4x : numpy.ndarray + list S31, S221, Sm22, Sm211, Sm31 + nf : int + numeber of active flavor below the threshold + + Returns + ------- + A_qg_3 : complex + :math:`A_{qg}^{S,(3)}(N)` + """ S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] S21 = s3x[0] diff --git a/src/eko/matching_conditions/n3lo/aqqNS.py b/src/eko/matching_conditions/n3lo/aqqNS.py index 477bd9f9f..0149cdb4d 100644 --- a/src/eko/matching_conditions/n3lo/aqqNS.py +++ b/src/eko/matching_conditions/n3lo/aqqNS.py @@ -1,5 +1,4 @@ # -*- coding: utf-8 -*- -"""This module contains the |OME| aqqNS, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np @@ -8,6 +7,32 @@ @nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals + r""" + Computes the |N3LO| singlet |OME| :math:`A_{qq}^{NS,(3)}(N)`. + The experssion is presented in :cite:`Bierenbaum_2009`. + It contains some weight 5 harmonics sums. + + Parameters + ---------- + n : complex + Mellin moment + sx : numpy.ndarray + list S1 ... S5 + smx : numpy.ndarray + list Sm1 ... Sm5 + s3x : numpy.ndarray + list S21, S2m1, Sm21, Sm2m1 + s4x : numpy.ndarray + list S31, S221, Sm22, Sm211, Sm31 + nf : int + numeber of active flavor below the threshold + + Returns + ------- + A_qqNS_3 : complex + :math:`A_{qq}^{NS,(3)}(N)` + + """ S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] Sm1, Sm2, Sm3, Sm4, Sm5 = smx[0], smx[1], smx[2], smx[3], smx[4] S21, S2m1, Sm21 = s3x[0], s3x[1], s3x[2] diff --git a/src/eko/matching_conditions/n3lo/aqqPS.py b/src/eko/matching_conditions/n3lo/aqqPS.py index e22773907..53f2be3a0 100644 --- a/src/eko/matching_conditions/n3lo/aqqPS.py +++ b/src/eko/matching_conditions/n3lo/aqqPS.py @@ -1,11 +1,28 @@ # -*- coding: utf-8 -*- -"""This module contains the |OME| aqqPS, the experssions are taken from :cite:`Bierenbaum_2009`""" import numba as nb import numpy as np @nb.njit("c16(c16,c16[:],u4)", cache=True) def A_qqPS_3(n, sx, nf): + r""" + Computes the |N3LO| singlet |OME| :math:`A_{qq}^{PS,(3)}(N)`. + The expression is presented in :cite:`Bierenbaum_2009` + + Parameters + ---------- + n : complex + Mellin moment + sx : numpy.ndarray + list S1 ... S5 + nf : int + numeber of active flavor below the threshold + + Returns + ------- + A_qqPS_3 : complex + :math:`A_{qq}^{PS,(3)}(N)` + """ S1, S2, S3 = sx[0], sx[1], sx[2] return ( 0.3333333333333333 From 9e9bf4ae23a7d9dcb1d9c19e58f504c9afa9bfe0 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 5 Oct 2021 18:51:07 +0200 Subject: [PATCH 49/71] Minor fix on indentation --- src/eko/matching_conditions/n3lo/aqqNS.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/aqqNS.py b/src/eko/matching_conditions/n3lo/aqqNS.py index 0149cdb4d..056bcaf09 100644 --- a/src/eko/matching_conditions/n3lo/aqqNS.py +++ b/src/eko/matching_conditions/n3lo/aqqNS.py @@ -7,7 +7,7 @@ @nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals - r""" + r""" Computes the |N3LO| singlet |OME| :math:`A_{qq}^{NS,(3)}(N)`. The experssion is presented in :cite:`Bierenbaum_2009`. It contains some weight 5 harmonics sums. @@ -31,7 +31,6 @@ def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals ------- A_qqNS_3 : complex :math:`A_{qq}^{NS,(3)}(N)` - """ S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] Sm1, Sm2, Sm3, Sm4, Sm5 = smx[0], smx[1], smx[2], smx[3], smx[4] From d6f2e3c280f87bbcc1602cc09793a0daa033877f Mon Sep 17 00:00:00 2001 From: Giacomo Magni Date: Wed, 6 Oct 2021 11:38:23 +0200 Subject: [PATCH 50/71] Run matching in parallel and submit script --- backward_paper/navigator.py | 2 +- backward_paper/submit_stoomboot.sh | 34 +++ .../operator_matrix_element.py | 234 ++++++++++++++---- 3 files changed, 219 insertions(+), 51 deletions(-) create mode 100755 backward_paper/submit_stoomboot.sh diff --git a/backward_paper/navigator.py b/backward_paper/navigator.py index 5542438eb..9d3bc1c85 100644 --- a/backward_paper/navigator.py +++ b/backward_paper/navigator.py @@ -73,7 +73,7 @@ def search_label(self, log, key): theory = self.get(bnav.t, log["t_hash"]) label = theory[key] if key == "PTO": - pto_dict = {0: "LO", 1: "NLO", 2: "NNLO"} + pto_dict = {0: "LO", 1: "NLO", 2: "NNLO", 3: "N3LO"} label = pto_dict[label] except KeyError: try: diff --git a/backward_paper/submit_stoomboot.sh b/backward_paper/submit_stoomboot.sh new file mode 100755 index 000000000..70fd9c66b --- /dev/null +++ b/backward_paper/submit_stoomboot.sh @@ -0,0 +1,34 @@ +#!/bin/bash + +#GLOBAL PATHS +PY='/project/theorie/gmagni/miniconda3/envs/nnpdf/bin/python' + +function submit_job () { + + # RUN SETUP + RUNNAME=$1 + NCORES=$2 + WALLTIME=$3 + + + COMMAND=$PWD'/launch_'$RUNNAME'.sh' + RUNNER_PATH=$PWD + LOG_PATH=$PWD'/logs' + + LAUNCH=$PY' '$RUNNER_PATH'/evolve_backward.py > '$LOG_PATH'/output_'$RUNNAME'.log' + + + [ -e $COMMAND ] && rm $COMMAND + mkdir -p $LOG_PATH + echo $LAUNCH >> $COMMAND + chmod +x $COMMAND + + # submission + qsub -q smefit -W group_list=smefit -l nodes=1:ppn=$NCORES -l walltime=$WALLTIME $COMMAND # -l pvmem=16000mb + # qsub -q long7 -W group_list=theorie -l nodes=1:ppn=$NCORES -l walltime=$WALLTIME $COMMAND + # cleaning + rm $COMMAND +} + +# submit_job 'n3lo_matching_exact_long' '1' '96:00:00' +submit_job 'n3lo_matching_expanded_parallel_32' '32' '48:00:00' \ No newline at end of file diff --git a/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index 05e6e1d8f..d33fcf8c2 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -6,11 +6,14 @@ import logging import time +import multiprocessing +import functools import numba as nb import numpy as np from scipy import integrate + from .. import interpolation, mellin from ..anomalous_dimensions import harmonics from ..basis_rotation import singlet_labels @@ -20,38 +23,48 @@ logger = logging.getLogger(__name__) + @nb.njit("c16[:](c16)", cache=True) def get_smx(n): """Get the S-minus cache""" - return np.array([ + return np.array( + [ s_functions.harmonic_Sm1(n), s_functions.harmonic_Sm2(n), s_functions.harmonic_Sm3(n), s_functions.harmonic_Sm4(n), s_functions.harmonic_Sm5(n), - ]) + ] + ) + @nb.njit("c16[:](c16,c16[:],c16[:])", cache=True) def get_s3x(n, sx, smx): """Get the S-w3 cache""" - return np.array([ + return np.array( + [ s_functions.harmonic_S21(n, sx[0], sx[1]), s_functions.harmonic_S2m1(n, sx[1], smx[0], smx[1]), s_functions.harmonic_Sm21(n, smx[0]), s_functions.harmonic_Sm2m1(n, sx[0], sx[1], smx[1]), - ]) + ] + ) + @nb.njit("c16[:](c16,c16[:],c16[:])", cache=True) def get_s4x(n, sx, smx): """Get the S-w4 cache""" Sm31 = s_functions.harmonic_Sm31(n, smx[0], smx[1]) - return np.array([ + return np.array( + [ s_functions.harmonic_S31(n, sx[1], sx[3]), s_functions.harmonic_S211(n, sx[0], sx[1], sx[2]), s_functions.harmonic_Sm22(n, Sm31), - s_functions.harmonic_Sm211(n, smx[0] ), + s_functions.harmonic_Sm211(n, smx[0]), s_functions.harmonic_Sm31(n, smx[0], smx[1]), - ]) + ] + ) + # @nb.njit("c16[:,:,:](u1,c16,c16[:],u4,f8)", cache=True) def A_singlet(order, n, sx, nf, L): @@ -66,6 +79,8 @@ def A_singlet(order, n, sx, nf, L): Mellin variable sx : numpy.ndarray List of harmonic sums + nf: int + number of active flavor below threshold L : float :math:`log(q^2/m_h^2)` @@ -106,6 +121,8 @@ def A_non_singlet(order, n, sx, nf, L): Mellin variable sx : numpy.ndarray List of harmonic sums + nf: int + number of active flavor below threshold L : float :math:`log(q^2/m_h^2)` @@ -163,7 +180,11 @@ def build_ome(A, order, a_s, backward_method): ) if order >= 3: ome += a_s ** 3 * ( - -A[2] + 2 * np.ascontiguousarray(A[0]) @ np.ascontiguousarray(A[1]) - np.ascontiguousarray(A[0]) @ np.ascontiguousarray(A[0]) @ np.ascontiguousarray(A[0]) + -A[2] + + 2 * np.ascontiguousarray(A[0]) @ np.ascontiguousarray(A[1]) + - np.ascontiguousarray(A[0]) + @ np.ascontiguousarray(A[0]) + @ np.ascontiguousarray(A[0]) ) else: # forward or exact inverse @@ -200,6 +221,8 @@ def quad_ker(u, order, mode, is_log, logx, areas, a_s, nf, L, backward_method): basis function configuration a_s : float strong coupling, needed only for the exact inverse + nf: int + number of active flavor below threshold L : float :math:`log(q^2/m_h^2)` backward_method : ["exact", "expanded" or ""] @@ -211,7 +234,7 @@ def quad_ker(u, order, mode, is_log, logx, areas, a_s, nf, L, backward_method): """ is_singlet = mode[0] == "S" # get transformation to N integral - r = 0.4 * 16.0 / ( 1.0 - logx) + r = 0.4 * 16.0 / (1.0 - logx) if is_singlet: o = 1.0 indeces = {"g": 0, "q": 1, "H": 2} @@ -232,8 +255,8 @@ def quad_ker(u, order, mode, is_log, logx, areas, a_s, nf, L, backward_method): sx = np.append(sx, harmonics.harmonic_S5(n)) smx = get_smx(n) sx = np.append(sx, smx) - sx = np.append(sx, get_s3x(n, sx,smx)) - sx = np.append(sx, get_s4x(n, sx,smx)) + sx = np.append(sx, get_s3x(n, sx, smx)) + sx = np.append(sx, get_s4x(n, sx, smx)) # compute the ome if is_singlet: A = A_singlet(order, n, sx, nf, L) @@ -262,6 +285,99 @@ def quad_ker(u, order, mode, is_log, logx, areas, a_s, nf, L, backward_method): return np.real(mellin_prefactor * ker * pj * jac) +def run_op_integration( + log_grid, + int_disp, + grid_size, + labels, + order, + is_log, + a_s, + nf, + L, + backward_method, +): + """ + Integration rutine per operator + Parameters + ---------- + log_grid : tuple(k, logx) + log grid with relative indices + int_disp : eko.interpolation.interpolation_dispatcher + instance of the interpolation dispatcher + grid_size : int + length of the grid + labels : numpy.ndarray + list of ome labels + order : int + perturbation order + is_log : boolean + logarithmic interpolation + logx : float + Mellin inversion point + a_s : float + strong coupling, needed only for the exact inverse + nf: int + number of active flavor below threshold + L : float + :math:`log(q^2/m_h^2)` + backward_method : ["exact", "expanded" or ""] + empty or method for inverting the matching contidtion (exact or expanded) + Returns + ------- + ker : float + evaluated integration kernel + """ + column = [] + k, logx = log_grid + logger.info( + "Matching: start computing operators - %d/%d", + k + 1, + grid_size, + ) + start_time = time.perf_counter() + # iterate basis functions + for l, bf in enumerate(int_disp): + if k == l and l == grid_size - 1: + continue + temp_dict = {} + # iterate sectors + for label in labels: + # compute and set + logger.info( + "Matching: %d operator is computing entry %d, %s", k + 1, l + 1, label + ) + res = integrate.quad( + quad_ker, + 0.5, + 1.0 - 1e-02, + args=( + order, + label, + is_log, + logx, + bf.areas_representation, + a_s, + nf, + L, + backward_method, + ), + epsabs=1e-12, + epsrel=1e-5, + limit=100, + full_output=1, + ) + temp_dict[label] = res[:2] + column.append(temp_dict) + logger.info( + "Matching: computing operators - %d/%d took: %f s", + k + 1, + grid_size, + time.perf_counter() - start_time, + ) + return column + + class OperatorMatrixElement: """ Internal representation of a single |OME|. @@ -353,49 +469,67 @@ def compute(self, q2, nf, L): a_s = self.sc.a_s(q2 / self.config["fact_to_ren"], q2) tot_start_time = time.perf_counter() - logger.info("Matching: computing operators - 0/%d", grid_size) + # logger.info("Matching: computing operators - 0/%d", grid_size) # iterate output grid - for k, logx in enumerate(np.log(self.int_disp.xgrid_raw)): - start_time = time.perf_counter() - # iterate basis functions - for l, bf in enumerate(self.int_disp): - if k == l and l == grid_size - 1: - continue - # iterate sectors - for label in labels: - logger.info("Matching: computing entry %s", label) - # compute and set - res = integrate.quad( - quad_ker, - 0.5, - 1.0 - self._mellin_cut, - args=( - self.config["order"], - label, - self.int_disp.log, - logx, - bf.areas_representation, - a_s, - nf, - L, - self.backward_method, - ), - epsabs=1e-12, - epsrel=1e-5, - limit=100, - full_output=1, - ) - val, err = res[:2] + # for k, logx in enumerate(np.log(self.int_disp.xgrid_raw)): + # start_time = time.perf_counter() + # # iterate basis functions + # for l, bf in enumerate(self.int_disp): + # if k == l and l == grid_size - 1: + # continue + # # iterate sectors + # for label in labels: + # logger.info("Matching: computing entry %s", label) + # # compute and set + # res = integrate.quad( + # quad_ker, + # 0.5, + # 1.0 - self._mellin_cut, + # args=( + # self.config["order"], + # label, + # self.int_disp.log, + # logx, + # bf.areas_representation, + # a_s, + # nf, + # L, + # self.backward_method, + # ), + # epsabs=1e-12, + # epsrel=1e-5, + # limit=100, + # full_output=1, + # ) + # val, err = res[:2] + # self.ome_members[label].value[k][l] = val + # self.ome_members[label].error[k][l] = err + + # run integration in parallel for each grid point + pool = multiprocessing.Pool(grid_size) + res = pool.map( + functools.partial( + run_op_integration, + int_disp=self.int_disp, + grid_size=grid_size, + labels=labels, + order=self.config["order"], + is_log=self.int_disp.log, + a_s=a_s, + nf=nf, + L=L, + backward_method=self.backward_method, + ), + enumerate(np.log(self.int_disp.xgrid_raw)), + ) + + # collect relusts + for k, row in enumerate(res): + for l, entry in enumerate(row): + for label, (val, err) in entry.items(): self.ome_members[label].value[k][l] = val self.ome_members[label].error[k][l] = err - logger.info( - "Matching: computing operators - %d/%d took: %f s", - k + 1, - grid_size, - time.perf_counter() - start_time, - ) - # closing comment logger.info("Matching: Total time %f s", time.perf_counter() - tot_start_time) self.copy_ome() From 30315f1aa6e41be43560f57c2dc4bffb7a4f9bf6 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 7 Oct 2021 14:17:27 +0200 Subject: [PATCH 51/71] Improve Hq asymtotic limit and aggTF2 binfact --- src/eko/matching_conditions/n3lo/aHq.py | 158 ++++++++++++--------- src/eko/matching_conditions/n3lo/agg.py | 3 +- src/eko/matching_conditions/n3lo/aggTF2.py | 13 +- tests/test_matching_n3lo.py | 4 +- 4 files changed, 106 insertions(+), 72 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/aHq.py b/src/eko/matching_conditions/n3lo/aHq.py index 4d14d2c31..271f97611 100644 --- a/src/eko/matching_conditions/n3lo/aHq.py +++ b/src/eko/matching_conditions/n3lo/aHq.py @@ -42,59 +42,75 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals H22 = hf.H22(n, S1) H24 = hf.H24(n, S1) H25 = hf.H25(n, S1, S2) - S1l05 = cs.S1l05(n) - S111l211 = cs.S111l211(H22, H24) - S12l21 = cs.S12l21(H25) - S21l21 = cs.S21l21(n, S1) - S3l2 = cs.S3l2(n) - S31l205 = cs.S31l205(n, S1, S2, S3) - - H1 = S111l211 + S12l21 - S21l21 - S3l2 + if np.abs(n) <= 32: + S111l211 = cs.S111l211(H22, H24) + S12l21 = cs.S12l21(H25) + S21l21 = cs.S21l21(n, S1) + S3l2 = cs.S3l2(n) + H1 = S111l211 + S12l21 - S21l21 - S3l2 + H1fit = (H1 + 8.41439832211716) / np.power(2.0, n) + else: + # fit of 2^-N * (H1 + 8.41439832211716) + H1fit = -( + -3.47279 + + 8.10205 / n ** 6 + - 21.6478 / n ** 5 + + 23.4306 / n ** 4 + - 14.378 / n ** 3 + + 5.98402 / n ** 2 + - 1.12176 / n + + 1.38541 * np.log(n) + - 0.197835 * np.log(n) ** 2 + + 0.0100534 * np.log(n) ** 3 + ) if np.abs(n) <= 32: H21 = hf.H21(n, S1) H23 = hf.H23(n, S1) H26 = hf.H26(n, S1, S2) H27 = hf.H27(n, S1, S2, S3, H21, H23, H24, H25) + S1l05 = cs.S1l05(n) S1111l20511 = cs.S1111l20511(n, S1) S1111l21051 = cs.S1111l21051(n, S1, H21) S121l2051 = cs.S121l2051(n, S1, H23) - + S31l205 = cs.S31l205(n, S1, S2, S3) H2 = (-H26 + H27 + S1111l20511 + S1111l21051 - S121l2051 - S31l205) - S1l05 * H1 + prefactor = (2.0 + n + np.power(n, 2)) ** 2 / ( + (-1 + n) * (1 + n) ** 2 * n ** 2 * (2 + n) + ) + H2fit = prefactor * (-32.0 * H2 + 269.261 * S1l05) + H3fit = prefactor * (64.0 * H2 - 538.521 * S1l05) else: - H2 = ( - -S31l205 - + S1l05 * S3l2 - # Expansion of: - # H27 + S1111l20511 + S1111l21051 - S121l2051 - S1l05 * (S111l211 + S12l21) - + ( - -0.621442 - + 2.51724 / n ** 4 - + (328.162 * 2 ** (-2 - n)) / n ** 4 - - (44.4671 * 2 ** (-n)) / n ** 4 - + 1.5302 / n ** 3 - - (75.7296 * 2 ** (-2 - n)) / n ** 3 - + (10.2616 * 2 ** (-n)) / n ** 3 - + 0.072467 / n ** 2 - + (25.2432 * 2 ** (-2 - n)) / n ** 2 - - (3.42054 * 2 ** (-n)) / n ** 2 - + 1.64493 / n - - (25.2432 * 2 ** (-3 - n)) / n - + (3.42054 * 2 ** (-1 - n)) / n - - (6.75 * (0.577216 + np.log(n))) / n ** 4 - + (1.83333 * (0.577216 + np.log(n))) / n ** 3 - - (0.5 * (0.577216 + np.log(n))) / n ** 2 - ) - # Expansion of - H26 + S1l05 * (S21l21) - - ( - 1.5806185221185012 - - 0.22916666666666666 / n ** 4 - - 0.05555555555555555 / n ** 3 - + 0.25 / n ** 2 - + (2.75 / n ** 4 - 1.1666666666666667 / n ** 3 + 0.5 / n ** 2) - * (0.5772156649015329 + np.log(n)) - ) + # Fit of: prefactor * (-32.0 * H2 + 269.261 * S1l05) + H2fit = ( + -2.94796 + - 569.906 / n ** 7 + + 1573.22 / n ** 6 + - 1749.07 / n ** 5 + + 1058.46 / n ** 4 + - 410.445 / n ** 3 + + 163.322 / n ** 2 + + 12.1605 / n + + 1.42545 * np.log(n) + - 0.241309 * np.log(n) ** 2 + + 0.0142069 * np.log(n) ** 3 + ) + # Fit of: prefactor * (64.0 * H2 - 538.521 * S1l05) + H3fit = ( + 2.60443 + - 4176.98 / n ** 8 + + 12113.8 / n ** 7 + - 14492.0 / n ** 6 + + 9710.45 / n ** 5 + - 4159.4 / n ** 4 + + 1260.6 / n ** 3 + - 396.852 / n ** 2 + - 11.7973 / n + - 1.23104 * np.log(n) + + 0.203406 * np.log(n) ** 2 + - 0.0116772 * np.log(n) ** 3 ) + return ( 0.3333333333333333 * nf @@ -872,34 +888,38 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals * np.power(1.0 + n, 3) * np.power(2.0 + n, 2) ) - + ( - np.power(2.0, 5.0 - 1.0 * n) - * ( - 4.0 - - 2.0 * n - + 10.0 * np.power(n, 2) - - 1.0 * np.power(n, 3) - + np.power(n, 5) - ) - * (8.41439832211716 + H1) - ) + # + ( + # np.power(2.0, 5.0 - 1.0 * n) + # * ( + # 4.0 + # - 2.0 * n + # + 10.0 * np.power(n, 2) + # - 1.0 * np.power(n, 3) + # + np.power(n, 5) + # ) + # * (8.41439832211716 + H1) + # ) + + np.power(2.0, 5.0) + * H1fit + * (4.0 - 2.0 * n + 10.0 * np.power(n, 2) - np.power(n, 3) + np.power(n, 5)) / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 2)) + ( np.power(2.0 + n + np.power(n, 2), 2) * ( 212.26414844076453 - 0.2222222222222222 * np.power(S1, 4) - + 1.2020569031595942 * (37.333333333333336 * S1 - 448.0 * S1l05) + + 1.2020569031595942 * 37.333333333333336 * S1 # - 448.0 * S1l05) - 6.666666666666667 * np.power(S1, 2) * S2 + 15.333333333333334 * np.power(S2, 2) + 1.6449340668482262 * (-4.0 * np.power(S1, 2) + 12.0 * S2) + 138.66666666666666 * S211 + S1 * (-64.0 * S21 + 8.88888888888889 * S3) - + 64.0 * (H2) + # + 64.0 * (H2) + 41.333333333333336 * S4 ) ) / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + H3fit ) + 2.0 * ( @@ -1369,17 +1389,20 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals * np.power(1.0 + n, 3) * np.power(2.0 + n, 2) ) - + ( - np.power(2.0, 4.0 - 1.0 * n) - * ( - 4.0 - - 2.0 * n - + 10.0 * np.power(n, 2) - - 1.0 * np.power(n, 3) - + np.power(n, 5) - ) - * (-8.41439832211716 - H1) - ) + # + ( + # np.power(2.0, 4.0 - 1.0 * n) + # * ( + # 4.0 + # - 2.0 * n + # + 10.0 * np.power(n, 2) + # - 1.0 * np.power(n, 3) + # + np.power(n, 5) + # ) + # * (-8.41439832211716 - H1) + # ) + - np.power(2.0, 4.0) + * H1fit + * (4.0 - 2.0 * n + 10.0 * np.power(n, 2) - np.power(n, 3) + np.power(n, 5)) / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 2)) + ( ( @@ -1431,16 +1454,17 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals * ( -184.0593470475842 + 0.2222222222222222 * np.power(S1, 4) - + 269.2607463077491 * S1l05 + # + 269.2607463077491 * S1l05 + 22.666666666666668 * np.power(S1, 2) * S2 - 26.666666666666668 * S211 - + 32.0 * (-H2) + # + 32.0 * (-H2) + 37.333333333333336 * np.power(S1, 2) * Sm2 + 1.6449340668482262 * (4.0 * np.power(S1, 2) + 12.0 * S2 + 24.0 * Sm2) ) ) / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + H2fit + ( 5.333333333333333 * ( diff --git a/src/eko/matching_conditions/n3lo/agg.py b/src/eko/matching_conditions/n3lo/agg.py index 6adc7fad1..9ce59a9b1 100644 --- a/src/eko/matching_conditions/n3lo/agg.py +++ b/src/eko/matching_conditions/n3lo/agg.py @@ -1,9 +1,10 @@ # -*- coding: utf-8 -*- +import numba as nb import numpy as np from .aggTF2 import A_ggTF2_3 - +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) def A_gg_3(n, sx, smx, s3x, s4x, nf): r""" Computes the |N3LO| singlet |OME| :math:`A_{gg}^{S,(3)}(N)`. diff --git a/src/eko/matching_conditions/n3lo/aggTF2.py b/src/eko/matching_conditions/n3lo/aggTF2.py index 230054d03..5f9632a07 100644 --- a/src/eko/matching_conditions/n3lo/aggTF2.py +++ b/src/eko/matching_conditions/n3lo/aggTF2.py @@ -1,9 +1,10 @@ # -*- coding: utf-8 -*- +import numba as nb import numpy as np from .s_functions import binomial - +@nb.njit("c16(c16,c16[:],c16[:])", cache=True) def A_ggTF2_3(n, sx, s3x): r""" Computes the approximate incomplete part of :math:`A_{gg}^{S,(3)}(N)` @@ -28,7 +29,15 @@ def A_ggTF2_3(n, sx, s3x): """ S1, S2, S3 = sx[0], sx[1], sx[2] S21 = s3x[0] - binfact = binomial(2 * n, n) / 4 ** n + # here we use an approximation at large N + # for binomial(2 * n, n) / np.power(4, n) + # faster than the exact result + binfact = ( + 0.00275483 / n ** (7 / 2) + + 0.00440773 / n ** (5 / 2) + - 0.0705237 / n ** (3 / 2) + + 0.56419 / np.sqrt(n) + ) return 0.3333333333333333 * ( ( 0.1335618781288438 diff --git a/tests/test_matching_n3lo.py b/tests/test_matching_n3lo.py index 1c614c079..e19ead7db 100644 --- a/tests/test_matching_n3lo.py +++ b/tests/test_matching_n3lo.py @@ -186,7 +186,7 @@ def test_Bluemlein_3(): ) np.testing.assert_allclose( - aS3[2, 1], ref_val_Hq[L][idx], rtol=5e-3, atol=3e-4 + aS3[2, 1], ref_val_Hq[L][idx], rtol=5e-3, atol=5e-4 ) # here we have a different convention for (-1)^N, @@ -209,7 +209,7 @@ def test_Bluemlein_3(): if N != 100: # Limited in the small N region np.testing.assert_allclose(Aggtf2, ref_val_ggTF2[0][idx], rtol=15e-2) - np.testing.assert_allclose(Aggtf2, ref_ggTF_app[idx], rtol=3e-6) + np.testing.assert_allclose(Aggtf2, ref_ggTF_app[idx], rtol=2e-4) np.testing.assert_allclose( n3lo.agg.A_gg_3(N, sx, smx, s3x, s4x, nf) - Aggtf2, From a27cfbcef44d3c652cc80d9908ad54a11fcb56c8 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Thu, 7 Oct 2021 14:18:06 +0200 Subject: [PATCH 52/71] remove unused binfact --- src/eko/matching_conditions/n3lo/aggTF2.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/aggTF2.py b/src/eko/matching_conditions/n3lo/aggTF2.py index 5f9632a07..3bbf15266 100644 --- a/src/eko/matching_conditions/n3lo/aggTF2.py +++ b/src/eko/matching_conditions/n3lo/aggTF2.py @@ -2,8 +2,6 @@ import numba as nb import numpy as np -from .s_functions import binomial - @nb.njit("c16(c16,c16[:],c16[:])", cache=True) def A_ggTF2_3(n, sx, s3x): r""" From 8f4984d0e1769875b7d56447ed1c39180eb509d2 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 12 Oct 2021 17:19:54 +0200 Subject: [PATCH 53/71] Black and test run_integration --- backward_paper/runner.py | 2 +- benchmarks/runners/NNPDF_bench.py | 1 - src/eko/matching_conditions/n3lo/__init__.py | 2 +- src/eko/matching_conditions/n3lo/agg.py | 1 + src/eko/matching_conditions/n3lo/aggTF2.py | 1 + .../operator_matrix_element.py | 2 +- tests/test_ev_op_grid.py | 2 +- tests/test_matching_n3lo.py | 45 +--------- tests/test_ome.py | 83 +++++++++++++++++-- tests/test_strong_coupling.py | 2 +- 10 files changed, 84 insertions(+), 57 deletions(-) diff --git a/backward_paper/runner.py b/backward_paper/runner.py index c3b9e7f5c..f69bc4450 100644 --- a/backward_paper/runner.py +++ b/backward_paper/runner.py @@ -170,7 +170,7 @@ def log(self, theory, ocard, pdf, me, ext): # my_pdf_errs = res["errors"] if self.intermediate_Q: tab[ - f"EKO_@_{np.round(np.sqrt(q2), 2)}_>_{self.intermediate_Q}_>_{np.round(np.sqrt(q2), 2)}" + f"EKO_@_{np.round(np.sqrt(q2), 2)}_>_{self.intermediate_Q}_>_{np.round(np.sqrt(q2), 2)}" # pylint: disable=line-too-long ] = (xgrid * my_pdfs[key]) else: tab[f"EKO_@_{np.round(np.sqrt(q2), 2)}"] = xgrid * my_pdfs[key] diff --git a/benchmarks/runners/NNPDF_bench.py b/benchmarks/runners/NNPDF_bench.py index 3268eaf93..75df0bcca 100644 --- a/benchmarks/runners/NNPDF_bench.py +++ b/benchmarks/runners/NNPDF_bench.py @@ -2,7 +2,6 @@ """ Benchmark NNDPF31 pdf family """ -import numpy as np from ekomark.benchmark.runner import Runner diff --git a/src/eko/matching_conditions/n3lo/__init__.py b/src/eko/matching_conditions/n3lo/__init__.py index c030d2c4a..36d3f75c5 100644 --- a/src/eko/matching_conditions/n3lo/__init__.py +++ b/src/eko/matching_conditions/n3lo/__init__.py @@ -33,7 +33,7 @@ def A_singlet_3(n, sx_all, nf): sx_all : numpy.ndarray List of harmonic sums containing: [S1 ... S5, Sm1 ... Sm5, S21, S2m1, Sm21, Sm2m1, S31, S221, Sm22, Sm211, Sm31] - + Returns ------- A_S_3 : numpy.ndarray diff --git a/src/eko/matching_conditions/n3lo/agg.py b/src/eko/matching_conditions/n3lo/agg.py index 9ce59a9b1..63239e1a7 100644 --- a/src/eko/matching_conditions/n3lo/agg.py +++ b/src/eko/matching_conditions/n3lo/agg.py @@ -4,6 +4,7 @@ from .aggTF2 import A_ggTF2_3 + @nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) def A_gg_3(n, sx, smx, s3x, s4x, nf): r""" diff --git a/src/eko/matching_conditions/n3lo/aggTF2.py b/src/eko/matching_conditions/n3lo/aggTF2.py index 3bbf15266..30fdfc5c9 100644 --- a/src/eko/matching_conditions/n3lo/aggTF2.py +++ b/src/eko/matching_conditions/n3lo/aggTF2.py @@ -2,6 +2,7 @@ import numba as nb import numpy as np + @nb.njit("c16(c16,c16[:],c16[:])", cache=True) def A_ggTF2_3(n, sx, s3x): r""" diff --git a/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index d33fcf8c2..9c21b4334 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -302,7 +302,7 @@ def run_op_integration( Parameters ---------- log_grid : tuple(k, logx) - log grid with relative indices + log grid point with relative indices int_disp : eko.interpolation.interpolation_dispatcher instance of the interpolation dispatcher grid_size : int diff --git a/tests/test_ev_op_grid.py b/tests/test_ev_op_grid.py index 8e92930a8..a040320a2 100644 --- a/tests/test_ev_op_grid.py +++ b/tests/test_ev_op_grid.py @@ -9,7 +9,7 @@ import numpy as np import pytest -import eko.interpolation as interpolation +from eko import interpolation from eko.evolution_operator.grid import OperatorGrid from eko.strong_coupling import StrongCoupling from eko.thresholds import ThresholdsAtlas diff --git a/tests/test_matching_n3lo.py b/tests/test_matching_n3lo.py index e19ead7db..130c92161 100644 --- a/tests/test_matching_n3lo.py +++ b/tests/test_matching_n3lo.py @@ -4,8 +4,9 @@ import numpy as np from eko.anomalous_dimensions import harmonics -from eko.matching_conditions.n3lo import A_ns_3, A_singlet_3, A_qqNS_3, s_functions +from eko.matching_conditions.n3lo import A_ns_3, A_singlet_3, A_qqNS_3 from eko.matching_conditions import n3lo +from eko.matching_conditions.operator_matrix_element import get_s3x, get_s4x, get_smx def get_sx(N): @@ -22,48 +23,6 @@ def get_sx(N): return sx -def get_smx(N): - """Collect the Sminus-cache""" - smx = np.array( - [ - s_functions.harmonic_Sm1(N), - s_functions.harmonic_Sm2(N), - s_functions.harmonic_Sm3(N), - s_functions.harmonic_Sm4(N), - s_functions.harmonic_Sm5(N), - ] - ) - return smx - - -def get_s3x(N, sx, smx): - """Collect the Sminus-cache""" - s3x = np.array( - [ - s_functions.harmonic_S21(N, sx[0], sx[1]), - s_functions.harmonic_S2m1(N, sx[1], smx[0], smx[1]), - s_functions.harmonic_Sm21(N, smx[0]), - s_functions.harmonic_Sm2m1(N, sx[0], sx[1], smx[1]), - ] - ) - return s3x - - -def get_s4x(N, sx, smx): - """Collect the Sminus-cache""" - Sm31 = s_functions.harmonic_Sm31(N, smx[0], smx[1]) - s4x = np.array( - [ - s_functions.harmonic_S31(N, sx[1], sx[3]), - s_functions.harmonic_S211(N, sx[0], sx[1], sx[2]), - s_functions.harmonic_Sm22(N, Sm31), - s_functions.harmonic_Sm211(N, smx[0]), - Sm31, - ] - ) - return s4x - - def test_A_3(): nf = 3 N = 1.0 diff --git a/tests/test_ome.py b/tests/test_ome.py index e37f2d3ee..cbbd8684b 100644 --- a/tests/test_ome.py +++ b/tests/test_ome.py @@ -19,6 +19,7 @@ OperatorMatrixElement, build_ome, quad_ker, + run_op_integration, get_s3x, get_s4x, get_smx, @@ -131,18 +132,20 @@ def test_quad_ker(monkeypatch): ) # negate mellin prefactor monkeypatch.setattr(interpolation, "log_evaluate_Nx", lambda *args: 1) monkeypatch.setattr(interpolation, "evaluate_Nx", lambda *args: 1) + zeros = np.zeros((2, 2)) monkeypatch.setattr( "eko.matching_conditions.operator_matrix_element.A_non_singlet", - lambda *args: np.identity(2), + lambda *args: np.array([zeros, zeros, zeros]), ) + zeros = np.zeros((3, 3)) monkeypatch.setattr( "eko.matching_conditions.operator_matrix_element.A_singlet", - lambda *args: np.identity(3), + lambda *args: np.array([zeros, zeros, zeros]), ) for is_log in [True, False]: res_ns = quad_ker( u=0, - order=2, + order=3, mode="NS_qq", is_log=is_log, logx=0.0, @@ -155,7 +158,7 @@ def test_quad_ker(monkeypatch): np.testing.assert_allclose(res_ns, 1.0) res_s = quad_ker( u=0, - order=2, + order=3, mode="S_qq", is_log=is_log, logx=0.0, @@ -168,7 +171,7 @@ def test_quad_ker(monkeypatch): np.testing.assert_allclose(res_s, 1.0) res_s = quad_ker( u=0, - order=2, + order=3, mode="S_qg", is_log=is_log, logx=0.0, @@ -185,7 +188,7 @@ def test_quad_ker(monkeypatch): for label in labels: res_ns = quad_ker( u=0, - order=2, + order=3, mode=label, is_log=True, logx=0.0, @@ -216,7 +219,7 @@ def test_quad_ker(monkeypatch): for label in labels: res_ns = quad_ker( u=0, - order=2, + order=3, mode=label, is_log=True, logx=0.0, @@ -234,7 +237,7 @@ def test_quad_ker(monkeypatch): monkeypatch.setattr(interpolation, "log_evaluate_Nx", lambda *args: 0) res_ns = quad_ker( u=0, - order=2, + order=3, mode="NS_qq", is_log=True, logx=0.0, @@ -247,6 +250,70 @@ def test_quad_ker(monkeypatch): np.testing.assert_allclose(res_ns, 0.0) +def test_run_integration(): + # setup objs + theory_card = { + "alphas": 0.35, + "PTO": 2, + "ModEv": "TRN", + "fact_to_ren_scale_ratio": 1.0, + "Qref": np.sqrt(2), + "nfref": None, + "Q0": np.sqrt(2), + "NfFF": 3, + "IC": 1, + "IB": 0, + "mc": 1.0, + "mb": 4.75, + "mt": 173.0, + "kcThr": 0.0, + "kbThr": np.inf, + "ktThr": np.inf, + "MaxNfPdf": 6, + "MaxNfAs": 6, + } + + operators_card = { + "Q2grid": [1, 10], + "interpolation_xgrid": [0.1, 1.0], + "interpolation_polynomial_degree": 1, + "interpolation_is_log": True, + "debug_skip_singlet": True, + "debug_skip_non_singlet": False, + "ev_op_max_order": 1, + "ev_op_iterations": 1, + "backward_inversion": "", + } + g = OperatorGrid.from_dict( + theory_card, + operators_card, + ThresholdsAtlas.from_dict(theory_card), + StrongCoupling.from_dict(theory_card), + InterpolatorDispatcher.from_dict(operators_card), + ) + o = OperatorMatrixElement(g.config, g.managers, is_backward=False) + log_grid = np.log(o.int_disp.xgrid_raw) + res = run_op_integration( + log_grid=(len(log_grid) - 1, log_grid[-1]), + int_disp=o.int_disp, + labels=["NS_qq"], + is_log=True, + grid_size=len(log_grid), + a_s=0.333, + order=theory_card["PTO"], + L=0, + nf=4, + backward_method="", + ) + + # here the last point is a zero, by default + np.testing.assert_allclose(res[0]["NS_qq"], (0.0, 0.0)) + + # test that copy ome does not change anything + o.copy_ome() + np.testing.assert_allclose(0.0, o.ome_members["S_qq"].value) + + class TestOperatorMatrixElement: # setup objs theory_card = { diff --git a/tests/test_strong_coupling.py b/tests/test_strong_coupling.py index 7ab30adc9..b5b930095 100644 --- a/tests/test_strong_coupling.py +++ b/tests/test_strong_coupling.py @@ -114,7 +114,7 @@ def test_ref(self): alphas_ref = 0.118 scale_ref = 91.0 ** 2 for thresh_setup in thresh_setups: - for order in [0, 1, 2]: + for order in [0, 1, 2, 3]: for method in ["exact", "expanded"]: # create sc = StrongCoupling( From c701139e7d36bd25b749ae02b114c00d82d5c7da Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 12 Oct 2021 18:59:19 +0200 Subject: [PATCH 54/71] Fix NS and Singlet matching labels, skip mathcing integration at LO --- src/eko/matching_conditions/__init__.py | 6 +- .../operator_matrix_element.py | 18 +++-- tests/test_matching.py | 12 ++-- tests/test_ome.py | 67 ++++++++++++++----- 4 files changed, 68 insertions(+), 35 deletions(-) diff --git a/src/eko/matching_conditions/__init__.py b/src/eko/matching_conditions/__init__.py index 1742adcc6..f3b5a1116 100644 --- a/src/eko/matching_conditions/__init__.py +++ b/src/eko/matching_conditions/__init__.py @@ -45,7 +45,7 @@ def split_ad_to_evol_map( m = { "S.S": ome_members["S_qq"], - "S.g": ome_members["S_qg"], # This is always zero for the time being + "S.g": ome_members["S_qg"], "g.S": ome_members["S_gq"], "g.g": ome_members["S_gg"], "V.V": ome_members["NS_qq"], @@ -61,7 +61,7 @@ def split_ad_to_evol_map( hq = flavors.quark_names[nf] m.update( { - f"{hq}-.V": ome_members["NS_Hq"], + # f"{hq}-.V": ome_members["NS_Hq"], f"{hq}+.S": ome_members["S_Hq"], f"{hq}+.g": ome_members["S_Hg"], } @@ -81,7 +81,7 @@ def split_ad_to_evol_map( m.update( { f"{ihq}+.{ihq}+": ome_members["S_HH"], - # f"S.{ihq}+": ome_members["S_qH"], + f"S.{ihq}+": ome_members["S_qH"], f"g.{ihq}+": ome_members["S_gH"], f"{ihq}-.{ihq}-": ome_members["NS_HH"], # f"V.{ihq}-": ome_members["NS_qH"], diff --git a/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index 9c21b4334..caaa30308 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -421,13 +421,12 @@ def labels(self): if self.config["debug_skip_non_singlet"]: logger.warning("Matching: skipping non-singlet sector") else: - labels.extend(["NS_qq", "NS_Hq"]) + labels.extend(["NS_qq"]) if self.is_intrinsic or self.backward_method != "": # intrisic labels, which are not zero at NLO labels.append("NS_HH") - # if self.backward_method == "exact": - # # this contribution starts at NNLO, we don't have it for the moment - # labels.append("NS_qH") + # These contributions are included + # labels.extend(["NS_qH", "NS_Hq"]) # same for singlet if self.config["debug_skip_singlet"]: @@ -436,8 +435,8 @@ def labels(self): labels.extend([*singlet_labels, "S_Hg", "S_Hq"]) if self.is_intrinsic or self.backward_method != "": labels.extend(["S_gH", "S_HH"]) - # if self.backward_method == "exact": - # labels.extend(["S_qH"]) + if self.backward_method == "exact" and self.config["order"] >= 3: + labels.append("S_qH") return labels def compute(self, q2, nf, L): @@ -466,6 +465,13 @@ def compute(self, q2, nf, L): self.ome_members[n] = OpMember( np.zeros((grid_size, grid_size)), np.zeros((grid_size, grid_size)) ) + + # At LO you don't need anything else + if self.config["order"] == 0: + logger.info("Matching: no need to compute matching at LO") + self.copy_ome() + return + a_s = self.sc.a_s(q2 / self.config["fact_to_ren"], q2) tot_start_time = time.perf_counter() diff --git a/tests/test_matching.py b/tests/test_matching.py index 434028694..a7783a17c 100644 --- a/tests/test_matching.py +++ b/tests/test_matching.py @@ -47,7 +47,7 @@ def test_split_ad_to_evol_map(self): keys3 = [ "c+.S", "c+.g", - "c-.V", + # "c-.V", ] assert sorted([str(k) for k in a.op_members.keys()]) == sorted( [*triv_keys, *keys3] @@ -69,7 +69,7 @@ def test_split_ad_to_evol_map(self): self.update_intrinsic_OME(ome) c = MatchingCondition.split_ad_to_evol_map(ome, 3, 1, [4]) assert sorted([str(k) for k in c.op_members.keys()]) == sorted( - [*triv_keys, *keys3, "g.c+", "c+.c+", "c-.c-"] + [*triv_keys, *keys3, "S.c+", "g.c+", "c+.c+", "c-.c-"] ) assert_almost_equal( c.op_members[member.MemberName("V.V")].value, @@ -91,13 +91,13 @@ def test_split_ad_to_evol_map(self): *triv_keys, "T15.T15", "V15.V15", - # "S.b+", + "S.b+", "g.b+", # "V.b-", "b+.S", "b+.g", "b+.b+", - "b-.V", + # "b-.V", "b-.b-", ] ) @@ -105,10 +105,6 @@ def test_split_ad_to_evol_map(self): d.op_members[member.MemberName("V.V")].value, a.op_members[member.MemberName("V.V")].value, ) - assert_almost_equal( - d.op_members[member.MemberName("b-.V")].value, - ome["NS_Hq"].value, - ) assert_almost_equal( d.op_members[member.MemberName("b+.S")].value, ome["S_Hq"].value, diff --git a/tests/test_ome.py b/tests/test_ome.py index cbbd8684b..ff472421f 100644 --- a/tests/test_ome.py +++ b/tests/test_ome.py @@ -318,7 +318,7 @@ class TestOperatorMatrixElement: # setup objs theory_card = { "alphas": 0.35, - "PTO": 0, + "PTO": 3, "ModEv": "TRN", "fact_to_ren_scale_ratio": 1.0, "Qref": np.sqrt(2), @@ -336,6 +336,17 @@ class TestOperatorMatrixElement: "MaxNfPdf": 6, "MaxNfAs": 6, } + operators_card = { + "Q2grid": [20], + "interpolation_xgrid": [0.1, 1.0], + "interpolation_polynomial_degree": 1, + "interpolation_is_log": True, + "debug_skip_singlet": True, + "debug_skip_non_singlet": False, + "ev_op_max_order": 1, + "ev_op_iterations": 1, + "backward_inversion": "exact", + } def test_labels(self): for skip_singlet in [True, False]: @@ -358,39 +369,59 @@ def test_labels(self): StrongCoupling.from_dict(self.theory_card), InterpolatorDispatcher.from_dict(operators_card), ) - o = OperatorMatrixElement(g.config, g.managers, is_backward=False) + o = OperatorMatrixElement(g.config, g.managers, is_backward=True) labels = o.labels() - test_labels = ["NS_qq", "NS_Hq"] + test_labels = ["NS_qq", "NS_HH"] for l in test_labels: if skip_ns: assert l not in labels else: assert l in labels - test_labels = ["S_qq", "S_Hq", "S_gg", "S_Hg", "S_gH"] + test_labels = [ + "S_qq", + "S_Hq", + "S_gg", + "S_Hg", + "S_gH", + "S_qH", + "S_qH", + "S_qg", + "S_HH", + ] for l in test_labels: if skip_singlet: assert l not in labels else: assert l in labels - def test_compute(self): - operators_card = { - "Q2grid": [20], - "interpolation_xgrid": [0.001, 0.01, 0.1, 1.0], - "interpolation_polynomial_degree": 1, - "interpolation_is_log": True, - "debug_skip_singlet": False, - "debug_skip_non_singlet": False, - "ev_op_max_order": 1, - "ev_op_iterations": 1, - "backward_inversion": "exact", - } + def test_compute_n3lo(self): + g = OperatorGrid.from_dict( + self.theory_card, + self.operators_card, + ThresholdsAtlas.from_dict(self.theory_card), + StrongCoupling.from_dict(self.theory_card), + InterpolatorDispatcher.from_dict(self.operators_card), + ) + o = OperatorMatrixElement(g.config, g.managers, is_backward=True) + o.compute(self.theory_card["mb"] ** 2, nf=4, L=0) + + dim = o.ome_members["NS_qq"].value.shape + np.testing.assert_allclose(o.ome_members["NS_qH"].value, np.zeros(dim)) + np.testing.assert_allclose(o.ome_members["NS_Hq"].value, np.zeros(dim)) + + for label in ["NS_qq", "NS_HH"]: + mat = o.ome_members[label].value + np.testing.assert_allclose(mat, np.triu(mat)) + + def test_compute_lo(self): + self.theory_card.update({"PTO": 0}) + self.operators_card.update({"debug_skip_singlet": False}) g = OperatorGrid.from_dict( self.theory_card, - operators_card, + self.operators_card, ThresholdsAtlas.from_dict(self.theory_card), StrongCoupling.from_dict(self.theory_card), - InterpolatorDispatcher.from_dict(operators_card), + InterpolatorDispatcher.from_dict(self.operators_card), ) o = OperatorMatrixElement(g.config, g.managers, is_backward=False) o.compute(self.theory_card["mb"] ** 2, nf=4, L=0) From 52315d6309752f56c6df6cba0cacd28b2337a3cd Mon Sep 17 00:00:00 2001 From: Giacomo Magni Date: Fri, 22 Oct 2021 13:02:20 +0200 Subject: [PATCH 55/71] Adding dump logs to navigator --- backward_paper/navigator.py | 79 +++++++++++++++++++++++++++++++------ 1 file changed, 66 insertions(+), 13 deletions(-) diff --git a/backward_paper/navigator.py b/backward_paper/navigator.py index 9d3bc1c85..8103aa61c 100644 --- a/backward_paper/navigator.py +++ b/backward_paper/navigator.py @@ -5,6 +5,7 @@ import numpy as np import pandas as pd from scipy import integrate +import json from banana import navigator as bnav from banana import load_config @@ -68,6 +69,8 @@ def search_label(self, log, key): """ if key == "pdf": label = log["pdf"] + if label == "210701-n3fit-data-014": + label = "NNPDF40_nnlo_as_01180_w_EMC" elif key is not None: try: theory = self.get(bnav.t, log["t_hash"]) @@ -87,17 +90,13 @@ def search_label(self, log, key): label = "EKO" return label - def plot_logs( + def collect_logs( self, hashes, label_to_display=None, - rotate_to_pm_basis=True, - skip=None, - plot_pull=False, - plot_reldiff=False, ): """ - Plot two different logs with the same x grid + Collect logs with the same x grid and raname labels Parameters ---------- @@ -105,24 +104,20 @@ def plot_logs( log hash list to plot label_to_display: str key to display in the plot legend: 'pdf' or theory/operator key - rotate_to_pm_basis : bool - if True rotate to plus minus basis - skip : str - skip '+' or '-' distribution """ dfds = [] labels = [] - fig_name = "" + log_name = "" for h in hashes: log = self.get(bnav.l, h) dfds.append(log["log"]) - fig_name += f"{log['hash'][: self.hash_len]}_" + log_name += f"{log['hash'][: self.hash_len]}_" # search the label labels.append(self.search_label(log, label_to_display)) # build a total log table with new keys - fig_name = fig_name[:-1] + log_name = log_name[:-1] total_log = dfdict.DFdict() for n, dfd in enumerate(dfds): for pid, tab in dfd.items(): @@ -138,6 +133,33 @@ def plot_logs( new_key = key.replace("EKO", f"{labels[n]}") total_log[pid][new_key] = vals + return total_log, log_name + + def plot_logs( + self, + hashes, + label_to_display=None, + rotate_to_pm_basis=True, + skip=None, + plot_pull=False, + plot_reldiff=False, + ): + """ + Plot two different logs with the same x grid + + Parameters + ---------- + hashes : list + log hash list to plot + label_to_display: str + key to display in the plot legend: 'pdf' or theory/operator key + rotate_to_pm_basis : bool + if True rotate to plus minus basis + skip : str + skip '+' or '-' distribution + """ + total_log, fig_name = self.collect_logs(hashes, label_to_display) + plot_pdf( to_pm(total_log, skip) if rotate_to_pm_basis else total_log, fig_name, @@ -145,6 +167,36 @@ def plot_logs( plot_pull=plot_pull, ) + def dump_logs( + self, + hashes, + label_to_display=None, + rotate_to_pm_basis=True, + skip=None, + ): + """ + Dump logs with the same x grid to a json file + + Parameters + ---------- + hashes : list + log hash list to plot + label_to_display: str + key to display in the plot legend: 'pdf' or theory/operator key + rotate_to_pm_basis : bool + if True rotate to plus minus basis + skip : str + skip '+' or '-' distribution + """ + total_log, log_name = self.collect_logs(hashes, label_to_display) + if rotate_to_pm_basis: + total_log = to_pm(total_log, skip) + + with open(f"{log_name}.json", "w") as f: + for pdf, table in total_log.items(): + json.dump({pdf: table.to_dict()}, f) + f.close() + def compute_momentum_fraction( self, hashes, label_to_display=None, rotate_to_pm_basis=True, skip=None ): @@ -213,6 +265,7 @@ def launch_navigator(): plot_logs = app.plot_logs compute_mom = app.compute_momentum_fraction get_replica = app.get_replica +dump_logs = app.dump_logs # check_log = app.check_log # plot_pdfs = app.plot_pdfs From fd44defef7515b6469f4b3e851eb2eae8c1ab1cb Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Fri, 22 Oct 2021 13:42:19 +0200 Subject: [PATCH 56/71] Adding more references and docs --- doc/source/refs.bib | 124 ++++++++++++++---- doc/source/theory/Matching.rst | 22 +++- src/eko/matching_conditions/n3lo/aHq.py | 3 +- src/eko/matching_conditions/n3lo/aggTF2.py | 2 +- src/eko/matching_conditions/n3lo/aqqNS.py | 3 +- .../matching_conditions/n3lo/g_functions.py | 2 +- .../matching_conditions/n3lo/s_functions.py | 21 +-- 7 files changed, 127 insertions(+), 50 deletions(-) diff --git a/doc/source/refs.bib b/doc/source/refs.bib index 8d8a4a849..6630abb2d 100644 --- a/doc/source/refs.bib +++ b/doc/source/refs.bib @@ -388,41 +388,107 @@ @article{Bl_mlein_2000 pages={76–104} } -@article{Bl_mlein_2009, - title={Structural relations of harmonic sums and Mellin transforms up to weight w=5}, - volume={180}, - ISSN={0010-4655}, - url={http://dx.doi.org/10.1016/j.cpc.2009.07.004}, - DOI={10.1016/j.cpc.2009.07.004}, - number={11}, - journal={Computer Physics Communications}, - publisher={Elsevier BV}, - author={Blümlein, Johannes}, - year={2009}, - month={Nov}, - pages={2218–2249} +@article{Blumlein:2009ta, + author = "Blumlein, Johannes", + title = "{Structural Relations of Harmonic Sums and Mellin Transforms up to Weight w = 5}", + eprint = "0901.3106", + archivePrefix = "arXiv", + primaryClass = "hep-ph", + reportNumber = "DESY-07-042, SFB-CPP-09-05", + doi = "10.1016/j.cpc.2009.07.004", + journal = "Comput. Phys. Commun.", + volume = "180", + pages = "2218--2249", + year = "2009" } -@misc{ablinger2017heavy, - title={Heavy Flavor Wilson Coefficients in Deep-Inelastic Scattering: Recent Results}, - author={J. Ablinger and A. Behring and J. Blümlein and A. De Freitas and A. von Manteuffel and C. Schneider}, - year={2017}, - eprint={1711.07957}, - archivePrefix={arXiv}, - primaryClass={hep-ph} +@article{Bierenbaum:2009zt, + author = "Bierenbaum, Isabella and Blumlein, Johannes and Klein, Sebastian", + title = "{The Gluonic Operator Matrix Elements at O(alpha(s)**2) for DIS Heavy Flavor Production}", + eprint = "0901.0669", + archivePrefix = "arXiv", + primaryClass = "hep-ph", + reportNumber = "DESY-08-187, SFB-CPP-08-107, IFIC-08-68", + doi = "10.1016/j.physletb.2009.01.057", + journal = "Phys. Lett. B", + volume = "672", + pages = "401--406", + year = "2009" } -@misc{ablinger20143loop, - title={3-loop Massive $O(T_F^2)$ Contributions to the DIS Operator Matrix Element $A_{gg}$}, - author={J. Ablinger and J. Blümlein and A. De Freitas and A. Hasselhuhn and A. von Manteuffel and M. Round and C. Schneider}, - year={2014}, - eprint={1409.1435}, - archivePrefix={arXiv}, - primaryClass={hep-ph} +@article{Ablinger:2010ty, + author = "Ablinger, J. and Blumlein, J. and Klein, S. and Schneider, C. and Wissbrock, F.", + title = "{The $O(\alpha_s^3)$ Massive Operator Matrix Elements of $O(n_f)$ for the Structure Function $F_2(x,Q^2)$ and Transversity}", + eprint = "1008.3347", + archivePrefix = "arXiv", + primaryClass = "hep-ph", + reportNumber = "DESY-10-109, TTK-10-46, SFB-CPP-10-077, DESY-10--109, TTK--10--46, SFB-CPP-10--077", + doi = "10.1016/j.nuclphysb.2010.10.021", + journal = "Nucl. Phys. B", + volume = "844", + pages = "26--54", + year = "2011" +} + +@article{Ablinger:2014vwa, + author = {Ablinger, J. and Behring, A. and Bl\"umlein, J. and De Freitas, A. and Hasselhuhn, A. and von Manteuffel, A. and Round, M. and Schneider, C. and Wi\ss{}brock, F.}, + title = "{The 3-Loop Non-Singlet Heavy Flavor Contributions and Anomalous Dimensions for the Structure Function $F_2(x,Q^2)$ and Transversity}", + eprint = "1406.4654", + archivePrefix = "arXiv", + primaryClass = "hep-ph", + reportNumber = "DESY-13--210, DO--TH-13-11, MITP-14-028, SFB-CPP-14-26, LPN-14-074", + doi = "10.1016/j.nuclphysb.2014.07.010", + journal = "Nucl. Phys. B", + volume = "886", + pages = "733--823", + year = "2014" +} + +@article{Ablinger:2014uka, + author = {Ablinger, J. and Bl\"umlein, J. and De Freitas, A. and Hasselhuhn, A. and von Manteuffel, A. and Round, M. and Schneider, C.}, + title = "{The $O(\alpha_s^3 T_F^2)$ Contributions to the Gluonic Operator Matrix Element}", + eprint = "1405.4259", + archivePrefix = "arXiv", + primaryClass = "hep-ph", + reportNumber = "DESY-14-018, DO-TH-14-04, MITP-14-019, SFB-CPP-14-24, LPN-14-069, HIGGSTOOLS-14-006, DO-TH 14/04, MITP/14-019, SFB/CPP-14-24, LPN 14-069, Higgstools 14-006", + doi = "10.1016/j.nuclphysb.2014.05.028", + journal = "Nucl. Phys. B", + volume = "885", + pages = "280--317", + year = "2014" +} + +@article{Behring:2014eya, + author = {Behring, A. and Bierenbaum, I. and Bl\"umlein, J. and De Freitas, A. and Klein, S. and Wi\ss{}brock, F.}, + title = "{The logarithmic contributions to the $O(\alpha^3_s)$ asymptotic massive Wilson coefficients and operator matrix elements in deeply inelastic scattering}", + eprint = "1403.6356", + archivePrefix = "arXiv", + primaryClass = "hep-ph", + reportNumber = "DESY-11-144, DO-TH-13-33, SFB-CPP-14-002, LPN-14-002, HIGGSTOOLS-14-003, DESY-11--144, SFB-CPP-14--002, LPN-14--002, HIGGSTOOLS --14--003", + doi = "10.1140/epjc/s10052-014-3033-x", + journal = "Eur. Phys. J. C", + volume = "74", + number = "9", + pages = "3033", + year = "2014" +} + +@article{Blumlein:2017wxd, + author = {Bl\"umlein, Johannes and Ablinger, Jakob and Behring, Arnd and De Freitas, Abilio and von Manteuffel, Andreas and Schneider, Carsten and Schneider, C.}, + title = "{Heavy Flavor Wilson Coefficients in Deep-Inelastic Scattering: Recent Results}", + eprint = "1711.07957", + archivePrefix = "arXiv", + primaryClass = "hep-ph", + reportNumber = "DESY-17-199, DO-TH-17-33, TTK-17-39, MSUHEP-17-020", + doi = "10.22323/1.308.0031", + journal = "PoS", + volume = "QCDEV2017", + pages = "031", + year = "2017" } @article{Ablinger_2014, - title={The transition matrix element Agq(N) of the variable flavor number scheme at O(αs3)}, + title={The transition matrix element A_{gq}(N) of the Variable Flavor Number Scheme at O(α_s^3)}, volume={882}, ISSN={0550-3213}, url={http://dx.doi.org/10.1016/j.nuclphysb.2014.02.007}, @@ -436,7 +502,7 @@ @article{Ablinger_2014 } @article{Ablinger_2015, - title={The 3-loop pure singlet heavy flavor contributions to the structure functionF2(x,Q2)and the anomalous dimension}, + title={The 3-loop pure singlet heavy flavor contributions to the structure function F2(x,Q2) and the anomalous dimension}, volume={890}, ISSN={0550-3213}, url={http://dx.doi.org/10.1016/j.nuclphysb.2014.10.008}, diff --git a/doc/source/theory/Matching.rst b/doc/source/theory/Matching.rst index 6baebbbd4..dbfb32b47 100644 --- a/doc/source/theory/Matching.rst +++ b/doc/source/theory/Matching.rst @@ -66,26 +66,31 @@ Furthermore in the right side basis :math:`\tilde h^{+}, \tilde h^{-}` are intri The :math:`\mathbf{A}^{(n_f)}(\mu_{h+1}^2)` can be computed order by order in :math:`a_s`: .. math :: - \mathbf{A}^{(n_f)}(\mu_{h}^2) = \mathbf{I} + a_s^{(n_f)}(\mu_{h}^2) \mathbf{A}^{(n_f),(1)} + \left(a_s^{(n_f)}(\mu_{h}^2)\right)^2 \mathbf{A}^{(n_f),(2)} + \mathbf{A}^{(n_f)}(\mu_{h}^2) = \mathbf{I} + a_s^{(n_f)}(\mu_{h}^2) \mathbf{A}^{(n_f),(1)} + a_s^{(n_f),2}(\mu_{h}^2) \mathbf{A}^{(n_f),(2)} + a_s^{(n_f),3}(\mu_{h}^2) \mathbf{A}^{(n_f),(3)} -where the :math:`\mathbf{A}^{(n_f),(k)}` are given upto |NNLO| by the following expressions: +where the :math:`\mathbf{A}^{(n_f),(k)}` are given upto |N3LO| by the following expressions: .. math :: \mathbf{A}_{S,h^+}^{(n_f),(1)} &= \begin{pmatrix} A_{gg,H}^{S,(1)} & 0 & A_{gH}^{S,(1)} \\ 0 & 0 & 0 \\ A_{Hg}^{S,(1)} & 0 & A_{HH}^{(1)} \end{pmatrix} \\ \mathbf{A}_{nsv,h^-}^{(n_f),(1)} &= \begin{pmatrix} 0 & 0 \\ 0 & A_{HH}^{(1)}\end{pmatrix} \\ \mathbf{A}_{S,h^+}^{(n_f),(2)} &= \begin{pmatrix} A_{gg,H}^{S,(2)} & A_{gq,H}^{S,(2)} & 0 \\ 0 & A_{qq,H}^{ns,(2)} & 0 \\ A_{Hg}^{S,(2)} & A_{Hq}^{ps,(2)} & 0 \end{pmatrix} \\ - \mathbf{A}_{nsv,h^-}^{(n_f),(2)} &= \begin{pmatrix} A_{qq,H}^{ns,(2)} & 0 \\ 0 & 0 \end{pmatrix} - + \mathbf{A}_{nsv,h^-}^{(n_f),(2)} &= \begin{pmatrix} A_{qq,H}^{ns,(2)} & 0 \\ 0 & 0 \end{pmatrix} \\ + \mathbf{A}_{S,h^+}^{(n_f),(3)} &= \begin{pmatrix} A_{gg,H}^{S,(3)} & A_{gq,H}^{S,(3)} & 0 \\ A_{qg,H}^{S,(3)} & A_{qq,H}^{ns,(3)} + A_{qq,H}^{ps,(3)} & 0 \\ A_{Hg}^{S,(3)} & A_{Hq}^{ps,(3)} & 0 \end{pmatrix} \\ + \mathbf{A}_{nsv,h^-}^{(n_f),(3)} &= \begin{pmatrix} A_{qq,H}^{ns,(3)} & 0 \\ 0 & 0 \end{pmatrix} The coefficients :math:`A^{(n_f),(k)}_{ij}(z,\mu_{h}^2)` have been firstly computed in :cite:`Buza_1998` and have been :doc:`Mellin tranformed ` to be used inside EKO. They depend on the scale :math:`\mu_{h}^2` only through the logarithm :math:`\ln(\mu_{h}^2/m_{h}^2)`, in particular the coefficient :math:`A_{gg,H}^{S,(1)}` is fully proprtional to :math:`\ln(\mu_{h}^2/m_{h}^2)`. -We remark that contributions of the higher quark at |NNLO| have not been computed yet, thus the elements :math:`A_{qH}^{(2)},A_{gH}^{(2)}A_{HH}^{(2)}` are not encoded in EKO despite of being present. -On the other hand the elements :math:`A_{qq}^{ps},A_{qg}` are known to start at |N3LO|. +|N3LO| matrix elements have been presented in :cite:`Bierenbaum_2009` and following pubblications +:cite:`Ablinger:2010ty,Ablinger:2014vwa,Ablinger:2014uka,Behring:2014eya,Blumlein:2017wxd,Ablinger_2014,Ablinger_2015`. +At |N3LO| the part proprtional to :math:`\ln(\mu_{h}^2/m_{h}^2)` are implemented inside our code for simplicity, but are available. + +We remark that contributions of the higher quark at |NNLO| and |N3LO| have not been computed yet, thus the elements :math:`A_{qH}^{(2)},A_{gH}^{(2)}A_{HH}^{(2)}` are not encoded in EKO despite of being present. +On the other hand the elements :math:`A_{qq,H}^{ps},A_{qg,H}` are known to start at |N3LO|. The |OME| are also required in the context of the FONLL matching scheme :cite:`Forte:2010ta`. For :ref:`Intrinsic Evolution ` this leads to considerable simplifications :cite:`Ball:2015dpa`. @@ -117,7 +122,10 @@ EKO implements two different strategies to perform this operation, that can be s - ``backward_inversion = 'expanded'``: the matching matrices are inverted through a pertubative expansion in :math:`a_s` before the Mellin inversion: .. math :: - \mathbf{A}_{exp}^{-1}(\mu_{h}^2) &= \mathbf{I} - a_s(\mu_{h}^2) \mathbf{A}^{(1)} + a_s^2(\mu_{h}^2) \left [ \mathbf{A}^{(2)} - \left(\mathbf{A}^{(1)}\right)^2 \right ] + O(a_s^3) \\ + \mathbf{A}_{exp}^{-1}(\mu_{h}^2) &= \mathbf{I} \\ + & - a_s(\mu_{h}^2) \mathbf{A}^{(1)} \\ + & + a_s^2(\mu_{h}^2) \left [ \mathbf{A}^{(2)} - \left(\mathbf{A}^{(1)}\right)^2 \right ] \\ + & + a_s^3(\mu_{h}^2) \left [ - \mathbf{A}^{(3)} + 2 \mathbf{A}^{(1)} \mathbf{A}^{(2)} - \left( \mathbf{A}^{(1)} \right )^3 \right ] + O(a_s^4) \\ We emphasize that in the backward evolution, below the threshold, the remaining high quark PDFs are always intrinsic and do not evolve anymore. In fact, if the initial PDFs (above threshold) do contain an intrinsic contribution, this has to be evolved below the threhsold otherwise momentum sum rules diff --git a/src/eko/matching_conditions/n3lo/aHq.py b/src/eko/matching_conditions/n3lo/aHq.py index 271f97611..a014ac70a 100644 --- a/src/eko/matching_conditions/n3lo/aHq.py +++ b/src/eko/matching_conditions/n3lo/aHq.py @@ -10,7 +10,8 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals r""" Computes the |N3LO| singlet |OME| :math:`A_{Hq}^{S,(3)}(N)`. - The experssion is presented in :cite:`Ablinger_2015` (eq 5.1). + The experssion is presented in :cite:`Ablinger_2015` (eq 5.1) + and :cite:`Blumlein:2017wxd` (eq 3.1). It contains generalized harmonics sums, which are computed inside :ref:`eko.matching_conditions.n3lo.cs_functions` and use the libary mpmath which is not compatible with numba. diff --git a/src/eko/matching_conditions/n3lo/aggTF2.py b/src/eko/matching_conditions/n3lo/aggTF2.py index 30fdfc5c9..18b8bba02 100644 --- a/src/eko/matching_conditions/n3lo/aggTF2.py +++ b/src/eko/matching_conditions/n3lo/aggTF2.py @@ -8,7 +8,7 @@ def A_ggTF2_3(n, sx, s3x): r""" Computes the approximate incomplete part of :math:`A_{gg}^{S,(3)}(N)` prortional to :math:`T_{F}^2`. - The experssion is presented in :cite:`ablinger20143loop` (eq 13). + The experssion is presented in :cite:`Ablinger:2014uka` (eq 4.2). It contains a binomial factor which is computed with mpmath and is not comaptible with numba. diff --git a/src/eko/matching_conditions/n3lo/aqqNS.py b/src/eko/matching_conditions/n3lo/aqqNS.py index 056bcaf09..68447caf4 100644 --- a/src/eko/matching_conditions/n3lo/aqqNS.py +++ b/src/eko/matching_conditions/n3lo/aqqNS.py @@ -9,7 +9,8 @@ def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals r""" Computes the |N3LO| singlet |OME| :math:`A_{qq}^{NS,(3)}(N)`. - The experssion is presented in :cite:`Bierenbaum_2009`. + The experssion is presented in :cite:`Bierenbaum_2009` and + :cite:`Ablinger:2014vwa`. It contains some weight 5 harmonics sums. Parameters diff --git a/src/eko/matching_conditions/n3lo/g_functions.py b/src/eko/matching_conditions/n3lo/g_functions.py index f25b8e85a..5fee59405 100644 --- a/src/eko/matching_conditions/n3lo/g_functions.py +++ b/src/eko/matching_conditions/n3lo/g_functions.py @@ -184,7 +184,7 @@ def mellin_g18(N, S1, S2): So we implement eq 124 of :cite:`Bl_mlein_2000` but using :cite:`MuselliPhD` notation. - Parametersrrr + Parameters ---------- N : complex Mellin moment diff --git a/src/eko/matching_conditions/n3lo/s_functions.py b/src/eko/matching_conditions/n3lo/s_functions.py index 072e7df5f..f56624f20 100644 --- a/src/eko/matching_conditions/n3lo/s_functions.py +++ b/src/eko/matching_conditions/n3lo/s_functions.py @@ -31,9 +31,10 @@ def binomial(x, y): Returns ------- + ..math:: - \left(\begin{array}{c} x y \end{array}\right) = - \frac{1}{(x+1) Beta(x-y+1,y+1)} + \left(\begin{array}{c} x y \end{array}\right) = \frac{1}{(x+1) Beta(x-y+1,y+1)} + """ # return sp.gamma(x + 1) / (sp.gamma(y + 1) * sp.gamma(x - y + 1)) # more accurate for large numbers. @@ -179,7 +180,7 @@ def harmonic_Sm5(N): def harmonic_S21(N, S1, S2): r""" Analytic continuation of harmonic sum :math:`S_{2,1}(N)` - as implemented in eq B.5.77 of :cite:`MuselliPhD`and eq 37 of cite:`Bl_mlein_2000`. + as implemented in eq B.5.77 of :cite:`MuselliPhD` and eq 37 of cite:`Bl_mlein_2000`. Parameters ---------- @@ -237,7 +238,7 @@ def harmonic_Sm21(N, Sm1): def harmonic_S2m1(N, S2, Sm1, Sm2): r""" Analytic continuation of harmonic sum :math:`S_{2,-1}(N)` - as implemented in eq B.5.76 of :cite:`MuselliPhD`and eq 23 of cite:`Bl_mlein_2000`. + as implemented in eq B.5.76 of :cite:`MuselliPhD` and eq 23 of cite:`Bl_mlein_2000`. Parameters ---------- @@ -272,7 +273,7 @@ def harmonic_S2m1(N, S2, Sm1, Sm2): def harmonic_Sm31(N, Sm1, Sm2): r""" Analytic continuation of harmonic sum :math:`S_{-3,1}(N)` - as implemented in eq B.5.93 of :cite:`MuselliPhD`and eq 25 of cite:`Bl_mlein_2000`. + as implemented in eq B.5.93 of :cite:`MuselliPhD` and eq 25 of cite:`Bl_mlein_2000`. Parameters ---------- @@ -308,7 +309,7 @@ def harmonic_Sm31(N, Sm1, Sm2): def harmonic_Sm22(N, Sm31): r""" Analytic continuation of harmonic sum :math:`S_{-2,2}(N)` - as implemented in eq B.5.94 of :cite:`MuselliPhD`and eq 24 of cite:`Bl_mlein_2000`. + as implemented in eq B.5.94 of :cite:`MuselliPhD` and eq 24 of cite:`Bl_mlein_2000`. Parameters ---------- @@ -337,7 +338,7 @@ def harmonic_Sm22(N, Sm31): def harmonic_Sm211(N, Sm1): r""" Analytic continuation of harmonic sum :math:`S_{-2,1,1}(N)` - as implemented in eq B.5.104 of :cite:`MuselliPhD`and eq 27 of cite:`Bl_mlein_2000`. + as implemented in eq B.5.104 of :cite:`MuselliPhD` and eq 27 of cite:`Bl_mlein_2000`. Parameters ---------- @@ -370,7 +371,7 @@ def harmonic_Sm211(N, Sm1): def harmonic_Sm2m1(N, S1, S2, Sm2): r""" Analytic continuation of harmonic sum :math:`S_{-2,-1}(N)` - as implemented in eq B.5.74 of :cite:`MuselliPhD`and eq 38 of cite:`Bl_mlein_2000`. + as implemented in eq B.5.74 of :cite:`MuselliPhD` and eq 38 of cite:`Bl_mlein_2000`. Parameters ---------- @@ -399,7 +400,7 @@ def harmonic_Sm2m1(N, S1, S2, Sm2): def harmonic_S211(N, S1, S2, S3): r""" Analytic continuation of harmonic sum :math:`S_{2,1,1}(N)` - as implemented in eq B.5.115 of :cite:`MuselliPhD`and eq 40 of cite:`Bl_mlein_2000`. + as implemented in eq B.5.115 of :cite:`MuselliPhD` and eq 40 of cite:`Bl_mlein_2000`. Parameters ---------- @@ -428,7 +429,7 @@ def harmonic_S211(N, S1, S2, S3): def harmonic_S31(N, S2, S4): r""" Analytic continuation of harmonic sum :math:`S_{3,1}(N)` - as implemented in eq B.5.99 of :cite:`MuselliPhD`and eq 41 of cite:`Bl_mlein_2000`. + as implemented in eq B.5.99 of :cite:`MuselliPhD` and eq 41 of cite:`Bl_mlein_2000`. Parameters ---------- From b6693e95227f3e7329a8ce0446f267fde4d9d13a Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Fri, 22 Oct 2021 13:44:41 +0200 Subject: [PATCH 57/71] Fix typo --- doc/source/theory/Matching.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/doc/source/theory/Matching.rst b/doc/source/theory/Matching.rst index dbfb32b47..753c1be72 100644 --- a/doc/source/theory/Matching.rst +++ b/doc/source/theory/Matching.rst @@ -87,7 +87,8 @@ in particular the coefficient :math:`A_{gg,H}^{S,(1)}` is fully proprtional to : |N3LO| matrix elements have been presented in :cite:`Bierenbaum_2009` and following pubblications :cite:`Ablinger:2010ty,Ablinger:2014vwa,Ablinger:2014uka,Behring:2014eya,Blumlein:2017wxd,Ablinger_2014,Ablinger_2015`. -At |N3LO| the part proprtional to :math:`\ln(\mu_{h}^2/m_{h}^2)` are implemented inside our code for simplicity, but are available. +At |N3LO| the parts proprtional to :math:`\ln(\mu_{h}^2/m_{h}^2)` are not implemented inside our code for simplicity, +but are available. We remark that contributions of the higher quark at |NNLO| and |N3LO| have not been computed yet, thus the elements :math:`A_{qH}^{(2)},A_{gH}^{(2)}A_{HH}^{(2)}` are not encoded in EKO despite of being present. On the other hand the elements :math:`A_{qq,H}^{ps},A_{qg,H}` are known to start at |N3LO|. From 707b3da5a8e0e717dc1758c604175c86f0610ec3 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Fri, 22 Oct 2021 14:03:47 +0200 Subject: [PATCH 58/71] Further fix on B references --- doc/source/refs.bib | 25 +++++++++++------------ doc/source/theory/Matching.rst | 2 +- src/eko/matching_conditions/n3lo/aHg.py | 2 +- src/eko/matching_conditions/n3lo/agg.py | 2 +- src/eko/matching_conditions/n3lo/aqg.py | 2 +- src/eko/matching_conditions/n3lo/aqqNS.py | 2 +- src/eko/matching_conditions/n3lo/aqqPS.py | 2 +- src/eko/matching_conditions/nnlo.py | 4 ++-- tests/test_matching_n3lo.py | 2 +- tests/test_matching_nlo.py | 2 +- tests/test_matching_nnlo.py | 2 +- 11 files changed, 23 insertions(+), 24 deletions(-) diff --git a/doc/source/refs.bib b/doc/source/refs.bib index 6630abb2d..e56461910 100644 --- a/doc/source/refs.bib +++ b/doc/source/refs.bib @@ -344,19 +344,18 @@ @article{Ball_2016 } -@article{Bierenbaum_2009, - title={Mellin moments of the heavy flavor contributions to unpolarized deep-inelastic scattering at and anomalous dimensions}, - volume={820}, - ISSN={0550-3213}, - url={http://dx.doi.org/10.1016/j.nuclphysb.2009.06.005}, - DOI={10.1016/j.nuclphysb.2009.06.005}, - number={1-2}, - journal={Nuclear Physics B}, - publisher={Elsevier BV}, - author={Bierenbaum, Isabella and Blümlein, Johannes and Klein, Sebastian}, - year={2009}, - month={Oct}, - pages={417–482} +@article{Bierenbaum:2009mv, + author = "Bierenbaum, Isabella and Blumlein, Johannes and Klein, Sebastian", + title = "{Mellin Moments of the O(alpha**3(s)) Heavy Flavor Contributions to unpolarized Deep-Inelastic Scattering at Q**2 \ensuremath{>}\ensuremath{>} m**2 and Anomalous Dimensions}", + eprint = "0904.3563", + archivePrefix = "arXiv", + primaryClass = "hep-ph", + reportNumber = "DESY-09-057, SFB-CPP-09-033, IFIC-09-16", + doi = "10.1016/j.nuclphysb.2009.06.005", + journal = "Nucl. Phys. B", + volume = "820", + pages = "417--482", + year = "2009" } @article{Carrazza_2020, diff --git a/doc/source/theory/Matching.rst b/doc/source/theory/Matching.rst index 753c1be72..301091769 100644 --- a/doc/source/theory/Matching.rst +++ b/doc/source/theory/Matching.rst @@ -85,7 +85,7 @@ been :doc:`Mellin tranformed ` to be used inside EKO. They depend on the scale :math:`\mu_{h}^2` only through the logarithm :math:`\ln(\mu_{h}^2/m_{h}^2)`, in particular the coefficient :math:`A_{gg,H}^{S,(1)}` is fully proprtional to :math:`\ln(\mu_{h}^2/m_{h}^2)`. -|N3LO| matrix elements have been presented in :cite:`Bierenbaum_2009` and following pubblications +|N3LO| matrix elements have been presented in :cite:`Bierenbaum:2009mv` and following pubblications :cite:`Ablinger:2010ty,Ablinger:2014vwa,Ablinger:2014uka,Behring:2014eya,Blumlein:2017wxd,Ablinger_2014,Ablinger_2015`. At |N3LO| the parts proprtional to :math:`\ln(\mu_{h}^2/m_{h}^2)` are not implemented inside our code for simplicity, but are available. diff --git a/src/eko/matching_conditions/n3lo/aHg.py b/src/eko/matching_conditions/n3lo/aHg.py index 17d8e8f9f..ddb22bba6 100644 --- a/src/eko/matching_conditions/n3lo/aHg.py +++ b/src/eko/matching_conditions/n3lo/aHg.py @@ -10,7 +10,7 @@ def A_Hg_3(n, sx, smx, s3x, s4x, nf): r""" Computes the |N3LO| singlet |OME| :math:`A_{Hg}^{S,(3)}(N)`. - The experssion is presented in :cite:`Bierenbaum_2009` + The experssion is presented in :cite:`Bierenbaum:2009mv` Parameters ---------- diff --git a/src/eko/matching_conditions/n3lo/agg.py b/src/eko/matching_conditions/n3lo/agg.py index 63239e1a7..4a77918de 100644 --- a/src/eko/matching_conditions/n3lo/agg.py +++ b/src/eko/matching_conditions/n3lo/agg.py @@ -9,7 +9,7 @@ def A_gg_3(n, sx, smx, s3x, s4x, nf): r""" Computes the |N3LO| singlet |OME| :math:`A_{gg}^{S,(3)}(N)`. - The experssion is presented in :cite:`Bierenbaum_2009` + The experssion is presented in :cite:`Bierenbaum:2009mv` Parameters ---------- diff --git a/src/eko/matching_conditions/n3lo/aqg.py b/src/eko/matching_conditions/n3lo/aqg.py index 24bc99b12..945967d05 100644 --- a/src/eko/matching_conditions/n3lo/aqg.py +++ b/src/eko/matching_conditions/n3lo/aqg.py @@ -7,7 +7,7 @@ def A_qg_3(n, sx, smx, s3x, s4x, nf): r""" Computes the |N3LO| singlet |OME| :math:`A_{qg}^{S,(3)}(N)`. - The expression is presented in :cite:`Bierenbaum_2009` + The expression is presented in :cite:`Bierenbaum:2009mv` Parameters ---------- diff --git a/src/eko/matching_conditions/n3lo/aqqNS.py b/src/eko/matching_conditions/n3lo/aqqNS.py index 68447caf4..d2f776e3c 100644 --- a/src/eko/matching_conditions/n3lo/aqqNS.py +++ b/src/eko/matching_conditions/n3lo/aqqNS.py @@ -9,7 +9,7 @@ def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals r""" Computes the |N3LO| singlet |OME| :math:`A_{qq}^{NS,(3)}(N)`. - The experssion is presented in :cite:`Bierenbaum_2009` and + The experssion is presented in :cite:`Bierenbaum:2009mv` and :cite:`Ablinger:2014vwa`. It contains some weight 5 harmonics sums. diff --git a/src/eko/matching_conditions/n3lo/aqqPS.py b/src/eko/matching_conditions/n3lo/aqqPS.py index 53f2be3a0..1131365ab 100644 --- a/src/eko/matching_conditions/n3lo/aqqPS.py +++ b/src/eko/matching_conditions/n3lo/aqqPS.py @@ -7,7 +7,7 @@ def A_qqPS_3(n, sx, nf): r""" Computes the |N3LO| singlet |OME| :math:`A_{qq}^{PS,(3)}(N)`. - The expression is presented in :cite:`Bierenbaum_2009` + The expression is presented in :cite:`Bierenbaum:2009mv` Parameters ---------- diff --git a/src/eko/matching_conditions/nnlo.py b/src/eko/matching_conditions/nnlo.py index 446ff00bc..00c4790f6 100644 --- a/src/eko/matching_conditions/nnlo.py +++ b/src/eko/matching_conditions/nnlo.py @@ -7,7 +7,7 @@ (https://github.com/N3PDF/external/blob/master/qcdnum/qcdnum/pij/ome.f) and Mellin transformed with Mathematica. -The expession for A_Hg_2_l0 comes form :cite:`Bierenbaum_2009` +The expession for A_Hg_2_l0 comes form :cite:`Bierenbaum:2009zt` """ import numba as nb import numpy as np @@ -147,7 +147,7 @@ def A_hg_2(n, sx, L): r""" |NNLO| heavy-gluon |OME| :math:`A_{Hg}^{S,(2)}` given in Eq. (B.3) of :cite:`Buza_1998`. - The expession for A_Hg_2_l0 comes form :cite:`Bierenbaum_2009`. + The expession for A_Hg_2_l0 comes form :cite:`Bierenbaum:2009zt`. Parameters ---------- diff --git a/tests/test_matching_n3lo.py b/tests/test_matching_n3lo.py index 130c92161..aefb543ef 100644 --- a/tests/test_matching_n3lo.py +++ b/tests/test_matching_n3lo.py @@ -87,7 +87,7 @@ def test_A_3(): def test_Bluemlein_3(): - # Test against Blumlein OME implementation :cite:`Bierenbaum_2009`. + # Test against Blumlein OME implementation :cite:`Bierenbaum:2009mv`. # For singlet OME only even moments are available in that code. # Note there is a minus sign in the definition of L. diff --git a/tests/test_matching_nlo.py b/tests/test_matching_nlo.py index 5015c69ca..e7fb5c4a2 100644 --- a/tests/test_matching_nlo.py +++ b/tests/test_matching_nlo.py @@ -36,7 +36,7 @@ def test_A_1_shape(): def test_Bluemlein_1(): - # Test against Blumlein OME implementation :cite:`Bierenbaum_2009`. + # Test against Blumlein OME implementation :cite:`Bierenbaum:2009mv`. # Only even moments are available in that code. # Note there is a minus sign in the definition of L. diff --git a/tests/test_matching_nnlo.py b/tests/test_matching_nnlo.py index 8cd477b23..6aebc490d 100644 --- a/tests/test_matching_nnlo.py +++ b/tests/test_matching_nnlo.py @@ -75,7 +75,7 @@ def test_pegasus_sign(): def test_Bluemlein_2(): - # Test against Blumlein OME implementation :cite:`Bierenbaum_2009`. + # Test against Blumlein OME implementation :cite:`Bierenbaum:2009mv`. # For singlet OME only even moments are available in that code. # Note there is a minus sign in the definition of L. ref_val_gg = { From b16f7a2f3b0f6524edc621c15807f36e96929cf1 Mon Sep 17 00:00:00 2001 From: Giacomo Magni Date: Mon, 1 Nov 2021 19:05:21 +0100 Subject: [PATCH 59/71] Adding Q2 study runnner --- backward_paper/evolve_backward.py | 24 +++++---- backward_paper/q2_study.py | 83 ++++++++++++++++++++++++++++++ backward_paper/submit_stoomboot.sh | 11 ++-- tests/test_matching_nnlo.py | 2 +- 4 files changed, 106 insertions(+), 14 deletions(-) create mode 100644 backward_paper/q2_study.py diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index b80fe208f..32aab95a6 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -5,7 +5,8 @@ import numpy as np from ekomark.data import operators -#from eko.interpolation import make_grid, make_lambert_grid + +# from eko.interpolation import make_grid, make_lambert_grid from runner import BackwardPaperRunner @@ -83,7 +84,7 @@ def evolve_backward(self, pdf_name, q_high=1.65, q_low=1.5, return_to_Q0=False): self.fig_name = None if return_to_Q0: self.return_to_Q0 = return_to_Q0 - self.fig_name = f"back_forth_{pdf_name}_{q_low}_{q_high}_{operator_updates['backward_inversion'][0]}" + self.fig_name = f"back_forth_{pdf_name}_{q_low}_{q_high}_{operator_updates['backward_inversion'][0]}" # pylint: disable=line-too-long theory_updates["IC"] = 1 theory_updates["IB"] = 1 # self.rotate_to_evolution_basis = True @@ -142,9 +143,9 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): # Evolve below c threshold pdf_names = [ "NNPDF40_nnlo_as_01180", # NNLO, fitted charm - # "210629-theory-003", # NNLO, perturbative charm + # "NNPDF40_nnlo_pch_as_01180", # NNLO, perturbative charm # "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c - # "NNPDF31_nnlo_pch_as_0118" + # "210701-n3fit-meth-013", # NNPDF4.0 in flavour basis ] for name in pdf_names: @@ -154,11 +155,11 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): # # Test beclow above thr # myrunner.evolve_above_below_thr(name) - # # # Test exapanded/exact - # # myrunner.evolve_exact_expanded(name) + # # Test exapanded/exact + # myrunner.evolve_exact_expanded(name) # # Test perturbarive B - # pdf_name = "210629-n3fit-001" + # pdf_name = "NNPDF40_nnlo_as_01180" # myrunner.evolve_above_below_thr(pdf_name, q_high=5, heavy_quark="b") # # Test EKO back and forth @@ -166,6 +167,9 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): # myrunner.evolve_backward(pdf_name, q_low=5, q_high=4.91, return_to_Q0=True) # myrunner.evolve_backward(pdf_name, q_low=4.91, q_high=5, return_to_Q0=True) - # you can't use n3fit-001 here since it's not defined below the thr scale - # pdf_name = "210629-theory-003" - # myrunner.evolve_backward(pdf_name, q_low=1.65, q_high=1.5, return_to_Q0=True) + # forward matching + # q_low = 1.51 to compare with Silvia's plot + # pdf_name = "NNPDF40_nnlo_pch_as_01180" + # myrunner.evolve_backward(pdf_name, q_low=1.51, q_high=1.5, return_to_Q0=False) + # pdf_name = "NNPDF40_nnlo_as_01180" + # myrunner.evolve_backward(pdf_name, q_low=1.5101, q_high=1.65, return_to_Q0=False) diff --git a/backward_paper/q2_study.py b/backward_paper/q2_study.py new file mode 100644 index 000000000..a0bd917e9 --- /dev/null +++ b/backward_paper/q2_study.py @@ -0,0 +1,83 @@ +# -*- coding: utf-8 -*- +""" +This script compute an EKO at different Q2 and show the differences from pch and fitted charm +""" +import numpy as np + +from banana.data import cartesian_product +from ekomark.data import operators +from eko.interpolation import make_grid + +from runner import BackwardPaperRunner + + +class Q2gridRunner(BackwardPaperRunner): + """ + Evolve pch and fitted charm to different Q2 + with different soltuion methods. + """ + + external = "inputpdf" + + base_theory = { + "Qref": [9.1187600e01], + "alphas": [0.1180024], + "mc": [1.51], + "mb": [4.92], + "mt": [172.5], + "kcThr": [1.0], + "kbThr": [1.0], + "ktThr": [1.0], + "PTO": [2], + "IC": [1], + "IB": [1], + "ModEv": ["TRN","EXA"], + } + base_operator = { + "interpolation_xgrid": [make_grid(20, 30, x_min=1e-4).tolist()], + "interpolation_polynomial_degree": [4], + # "backward_inversion": ["exact"], + "ev_op_iterations": [1], + } + + def evolve_different_q2( + self, + pdf_name, + q_low=1.5, + ): + """ + Evolve pdf at differnt Q2 values + + Parameters + ---------- + pdf_name: str + PDF name + q_low: float + initial Q scale + """ + + self.fig_name = pdf_name + + theory_updates = self.base_theory.copy() + theory_updates["Q0"] = [q_low] + + operator_updates = self.base_operator.copy() + operator_updates["Q2grid"] = [list(np.power([1.65, 10, 100], 2))] + self.run( + cartesian_product(theory_updates), + operators.build((operator_updates)), + [pdf_name], + use_replicas=True, + ) + + +if __name__ == "__main__": + + myrunner = Q2gridRunner() + pdf_names = [ + # "NNPDF40_nnlo_as_01180", # NNLO, fitted charm + "NNPDF40_nnlo_pch_as_01180", # NNLO, perturbative charm + # "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c + ] + for name in pdf_names: + myrunner.evolve_different_q2(name) diff --git a/backward_paper/submit_stoomboot.sh b/backward_paper/submit_stoomboot.sh index 70fd9c66b..9be8a1596 100755 --- a/backward_paper/submit_stoomboot.sh +++ b/backward_paper/submit_stoomboot.sh @@ -9,13 +9,14 @@ function submit_job () { RUNNAME=$1 NCORES=$2 WALLTIME=$3 + PYTHONSCRIPT=$4 COMMAND=$PWD'/launch_'$RUNNAME'.sh' RUNNER_PATH=$PWD LOG_PATH=$PWD'/logs' - LAUNCH=$PY' '$RUNNER_PATH'/evolve_backward.py > '$LOG_PATH'/output_'$RUNNAME'.log' + LAUNCH=$PY' '$RUNNER_PATH'/'$PYTHONSCRIPT'.py > '$LOG_PATH'/output_'$RUNNAME'.log' [ -e $COMMAND ] && rm $COMMAND @@ -30,5 +31,9 @@ function submit_job () { rm $COMMAND } -# submit_job 'n3lo_matching_exact_long' '1' '96:00:00' -submit_job 'n3lo_matching_expanded_parallel_32' '32' '48:00:00' \ No newline at end of file +# submit_job 'n3lo_matching_exact_long' '1' '96:00:00' 'evolve_backward' +# submit_job 'n3lo_matching_exact_parallel_32' '32' '48:00:00' 'evolve_backward' +# submit_job 'n3lo_matching_exact_parallel_49' '49' '48:00:00' 'evolve_backward' +# submit_job 'n3lo_matching_expanded_parallel_49' '49' '48:00:00' 'evolve_backward' +# submit_job 'n3lo_matching_forward1.51_parallel_49' '49' '48:00:00' 'evolve_backward' +submit_job 'n3lo_matching_q2grid_parallel_49_exa' '49' '48:00:00' 'q2_study' \ No newline at end of file diff --git a/tests/test_matching_nnlo.py b/tests/test_matching_nnlo.py index 6aebc490d..e1fded14e 100644 --- a/tests/test_matching_nnlo.py +++ b/tests/test_matching_nnlo.py @@ -75,7 +75,7 @@ def test_pegasus_sign(): def test_Bluemlein_2(): - # Test against Blumlein OME implementation :cite:`Bierenbaum:2009mv`. + # Test against Blumlein OME implementation :cite:`Bierenbaum:2009zt`. # For singlet OME only even moments are available in that code. # Note there is a minus sign in the definition of L. ref_val_gg = { From 35117644961fa29f7e8d479de5f6b7221185fd09 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Tue, 2 Nov 2021 18:14:40 +0100 Subject: [PATCH 60/71] New A_Hq parametrization and complete numba in n3lo matching --- src/eko/matching_conditions/n3lo/__init__.py | 6 +- src/eko/matching_conditions/n3lo/aHq.py | 112 +++++++++++++----- src/eko/matching_conditions/n3lo/aqqNS.py | 2 +- .../operator_matrix_element.py | 8 +- tests/test_matching_n3lo.py | 4 +- 5 files changed, 92 insertions(+), 40 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/__init__.py b/src/eko/matching_conditions/n3lo/__init__.py index 36d3f75c5..ed15809c3 100644 --- a/src/eko/matching_conditions/n3lo/__init__.py +++ b/src/eko/matching_conditions/n3lo/__init__.py @@ -2,7 +2,7 @@ """ This module defines the matching conditions for the N3LO |VFNS| evolution. """ -# import numba as nb +import numba as nb import numpy as np from .agg import A_gg_3 @@ -14,7 +14,7 @@ from .aHq import A_Hq_3 -# @nb.njit("c16[:,:](c16,c16[:],u4)", cache=True) +@nb.njit("c16[:,:](c16,c16[:],u4)", cache=True) def A_singlet_3(n, sx_all, nf): r""" Computes the |N3LO| singlet |OME|. @@ -60,7 +60,7 @@ def A_singlet_3(n, sx_all, nf): return A_S_3 -# @nb.njit("c16[:,:](c16,c16[:],u4)", cache=True) +@nb.njit("c16[:,:](c16,c16[:],u4)", cache=True) def A_ns_3(n, sx_all, nf): r""" Computes the |N3LO| non-singlet |OME|. diff --git a/src/eko/matching_conditions/n3lo/aHq.py b/src/eko/matching_conditions/n3lo/aHq.py index a014ac70a..9b97dc608 100644 --- a/src/eko/matching_conditions/n3lo/aHq.py +++ b/src/eko/matching_conditions/n3lo/aHq.py @@ -2,11 +2,10 @@ # pylint: disable=too-many-lines """This module contains the |OME| aHq, the experssions are taken from """ import numpy as np - -from . import cs_functions as cs -from . import h_functions as hf +import numba as nb +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals r""" Computes the |N3LO| singlet |OME| :math:`A_{Hq}^{S,(3)}(N)`. @@ -36,22 +35,36 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals A_Hq_3 : complex :math:`A_{Hq}^{S,(3)}(N)` """ - S1, S2, S3, S4 = sx[0], sx[1], sx[2], sx[3] + S1, S2, S3, S4, S5 = sx[0], sx[1], sx[2], sx[3], sx[4] Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] S21, Sm21 = s3x[0], s3x[2] S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] - H22 = hf.H22(n, S1) - H24 = hf.H24(n, S1) - H25 = hf.H25(n, S1, S2) - if np.abs(n) <= 32: - S111l211 = cs.S111l211(H22, H24) - S12l21 = cs.S12l21(H25) - S21l21 = cs.S21l21(n, S1) - S3l2 = cs.S3l2(n) - H1 = S111l211 + S12l21 - S21l21 - S3l2 - H1fit = (H1 + 8.41439832211716) / np.power(2.0, n) + N_asy = 100.0 + + # fit of: + # 2^-N * ( H1 + 8.41439832211716) + # with_ + # H1 = S111l211 + S12l21 - S21l21 - S3l2 + if np.abs(n) <= N_asy: + H1fit = -( + 510293.43726255593 + - 5915.11168241528 / n ** 6 + + 33646.895861267105 / n ** 5 + - 94189.35516864149 / n ** 4 + + 168450.87857184012 / n ** 3 + - 188441.14940576284 / n ** 2 + + 26762.00346212842 / n + - 0.46328880737715383 * np.log(n) + - 0.2678498730023523 * np.log(n) ** 2 + + 0.02148061287110971 * np.log(n) ** 3 + - 0.0006754153597171009 * np.log(n) ** 4 + + 2.022675964189347 * S1 + + 26765.31463304929 * S2 + - 350138.44481493114 * S3 + - 33034.748321832885 * S4 + - 94205.95027238235 * S5 + ) else: - # fit of 2^-N * (H1 + 8.41439832211716) H1fit = -( -3.47279 + 8.10205 / n ** 6 @@ -65,22 +78,61 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals + 0.0100534 * np.log(n) ** 3 ) - if np.abs(n) <= 32: - H21 = hf.H21(n, S1) - H23 = hf.H23(n, S1) - H26 = hf.H26(n, S1, S2) - H27 = hf.H27(n, S1, S2, S3, H21, H23, H24, H25) - S1l05 = cs.S1l05(n) - S1111l20511 = cs.S1111l20511(n, S1) - S1111l21051 = cs.S1111l21051(n, S1, H21) - S121l2051 = cs.S121l2051(n, S1, H23) - S31l205 = cs.S31l205(n, S1, S2, S3) - H2 = (-H26 + H27 + S1111l20511 + S1111l21051 - S121l2051 - S31l205) - S1l05 * H1 - prefactor = (2.0 + n + np.power(n, 2)) ** 2 / ( - (-1 + n) * (1 + n) ** 2 * n ** 2 * (2 + n) + # fit of: + # H2fit = prefactor * (-32.0 * H2 + 269.261 * S1l05) + # H3fit = prefactor * (64.0 * H2 - 538.521 * S1l05) + # + # with: + # prefactor = (2.0 + n + np.power(n, 2)) ** 2 / ( + # (-1 + n) * (1 + n) ** 2 * n ** 2 * (2 + n) + # H26 = S211l2051 + S211l2105 - S22l205 + # H27 = + S1111l21105 + S112l2051 - S112l2105 + S121l2105 - S13l205 + # H2 = (-H26 + H27 + S1111l20511 + S1111l21051 - S121l2051 - S31l205) - S1l05 * H1 ) + if np.abs(n) <= N_asy: + H2fit = ( + 1.0 + / (n - 1.0) + * ( + -2.0013975529448013 * 10 ** 6 + + 19518.0430371964 / n ** 6 + - 116007.37632563594 / n ** 5 + + 338151.91317081364 / n ** 4 + - 626105.9371887271 / n ** 3 + + 721591.8278879325 / n ** 2 + - 111803.06753048327 / n + + 41.01614426167839 * np.log(n) + + 1.6933677549364727 * np.log(n) ** 2 + - 0.17531129453782482 * np.log(n) ** 3 + + 0.007102648526217874 * np.log(n) ** 4 + - 48.639798042178974 * S1 + - 112030.74846229349 * S2 + + 1.332436471931116 * 10 ** 6 * S3 + + 168654.6091181566 * S4 + + 387219.96426897356 * S5 + ) + ) + H3fit = ( + 1.0 + / (n - 1.0) + * ( + 7.02751915949495 * 10 ** 6 + - 72904.7106288313 / n ** 6 + + 426341.35916634067 / n ** 5 + - 1.2244158552672293 * 10 ** 6 / n ** 4 + + 2.2383093309891755 * 10 ** 6 / n ** 3 + - 2.5508113799279416 * 10 ** 6 / n ** 2 + + 379208.34283199214 / n + - 54.66137832505475 * np.log(n) + - 1.9305196326017733 * np.log(n) ** 2 + + 0.18896396372891952 * np.log(n) ** 3 + - 0.007195814902392234 * np.log(n) ** 4 + + 63.79777183250833 * S1 + + 379673.3075205668 * S2 + - 4.724705794745556 * 10 ** 6 * S3 + - 544875.9987908748 * S4 + - 1.3337605727428352 * 10 ** 6 * S5 + ) ) - H2fit = prefactor * (-32.0 * H2 + 269.261 * S1l05) - H3fit = prefactor * (64.0 * H2 - 538.521 * S1l05) else: # Fit of: prefactor * (-32.0 * H2 + 269.261 * S1l05) H2fit = ( diff --git a/src/eko/matching_conditions/n3lo/aqqNS.py b/src/eko/matching_conditions/n3lo/aqqNS.py index d2f776e3c..d42176d46 100644 --- a/src/eko/matching_conditions/n3lo/aqqNS.py +++ b/src/eko/matching_conditions/n3lo/aqqNS.py @@ -9,7 +9,7 @@ def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals r""" Computes the |N3LO| singlet |OME| :math:`A_{qq}^{NS,(3)}(N)`. - The experssion is presented in :cite:`Bierenbaum:2009mv` and + The experssion is presented in :cite:`Bierenbaum:2009mv` and :cite:`Ablinger:2014vwa`. It contains some weight 5 harmonics sums. diff --git a/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index caaa30308..2726dda40 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -66,7 +66,7 @@ def get_s4x(n, sx, smx): ) -# @nb.njit("c16[:,:,:](u1,c16,c16[:],u4,f8)", cache=True) +@nb.njit("c16[:,:,:](u1,c16,c16[:],u4,f8)", cache=True) def A_singlet(order, n, sx, nf, L): r""" Computes the tower of the singlet |OME|. @@ -108,7 +108,7 @@ def A_singlet(order, n, sx, nf, L): return A_singlet -# @nb.njit("c16[:,:,:](u1,c16,c16[:],u4,f8)", cache=True) +@nb.njit("c16[:,:,:](u1,c16,c16[:],u4,f8)", cache=True) def A_non_singlet(order, n, sx, nf, L): r""" Computes the tower of the non-singlet |OME| @@ -148,7 +148,7 @@ def A_non_singlet(order, n, sx, nf, L): return A_ns -# @nb.njit("c16[:,:](c16[:,:,:],u4,f8,string)", cache=True) +@nb.njit("c16[:,:](c16[:,:,:],u4,f8,string)", cache=True) def build_ome(A, order, a_s, backward_method): r""" Construct the matching expansion in :math:`a_s` with the appropriate method. @@ -200,7 +200,7 @@ def build_ome(A, order, a_s, backward_method): return ome -# @nb.njit("f8(f8,u1,string,b1,f8,f8[:,:],f8,u4,f8,string)", cache=True) +@nb.njit("f8(f8,u1,string,b1,f8,f8[:,:],f8,u4,f8,string)", cache=True) def quad_ker(u, order, mode, is_log, logx, areas, a_s, nf, L, backward_method): """ Raw kernel inside quad diff --git a/tests/test_matching_n3lo.py b/tests/test_matching_n3lo.py index aefb543ef..62c0629ba 100644 --- a/tests/test_matching_n3lo.py +++ b/tests/test_matching_n3lo.py @@ -145,7 +145,7 @@ def test_Bluemlein_3(): ) np.testing.assert_allclose( - aS3[2, 1], ref_val_Hq[L][idx], rtol=5e-3, atol=5e-4 + aS3[2, 1], ref_val_Hq[L][idx], rtol=2e-5, atol=1e-5 ) # here we have a different convention for (-1)^N, @@ -217,5 +217,5 @@ def test_AHq_asymptotic(): s3x = get_s3x(N, sx, smx) s4x = get_s4x(N, sx, smx) np.testing.assert_allclose( - n3lo.aHq.A_Hq_3(N, sx, smx, s3x, s4x, nf), r, rtol=5e-3, atol=5e-4 + n3lo.aHq.A_Hq_3(N, sx, smx, s3x, s4x, nf), r, rtol=1e-5, atol=1e-5 ) From 3005c4c3423193071a687ca844ffa1ed45e0e8f9 Mon Sep 17 00:00:00 2001 From: Giacomo Magni Date: Wed, 3 Nov 2021 13:10:02 +0100 Subject: [PATCH 61/71] small fix on q2 runner --- backward_paper/q2_study.py | 36 ++++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 16 deletions(-) diff --git a/backward_paper/q2_study.py b/backward_paper/q2_study.py index a0bd917e9..446dd7131 100644 --- a/backward_paper/q2_study.py +++ b/backward_paper/q2_study.py @@ -14,7 +14,7 @@ class Q2gridRunner(BackwardPaperRunner): """ Evolve pch and fitted charm to different Q2 - with different soltuion methods. + with different soltuion methods. """ external = "inputpdf" @@ -28,10 +28,10 @@ class Q2gridRunner(BackwardPaperRunner): "kcThr": [1.0], "kbThr": [1.0], "ktThr": [1.0], - "PTO": [2], + "PTO": [3], "IC": [1], "IB": [1], - "ModEv": ["TRN","EXA"], + "ModEv": ["TRN"], } base_operator = { "interpolation_xgrid": [make_grid(20, 30, x_min=1e-4).tolist()], @@ -40,11 +40,7 @@ class Q2gridRunner(BackwardPaperRunner): "ev_op_iterations": [1], } - def evolve_different_q2( - self, - pdf_name, - q_low=1.5, - ): + def evolve_different_q2(self, pdf_name, q_low=1.5, q_grid=[1.65, 10.0, 100.0]): """ Evolve pdf at differnt Q2 values @@ -54,6 +50,8 @@ def evolve_different_q2( PDF name q_low: float initial Q scale + q_grid: list + final Q scales """ self.fig_name = pdf_name @@ -62,7 +60,7 @@ def evolve_different_q2( theory_updates["Q0"] = [q_low] operator_updates = self.base_operator.copy() - operator_updates["Q2grid"] = [list(np.power([1.65, 10, 100], 2))] + operator_updates["Q2grid"] = [list(np.power(q_grid, 2))] self.run( cartesian_product(theory_updates), operators.build((operator_updates)), @@ -74,10 +72,16 @@ def evolve_different_q2( if __name__ == "__main__": myrunner = Q2gridRunner() - pdf_names = [ - # "NNPDF40_nnlo_as_01180", # NNLO, fitted charm - "NNPDF40_nnlo_pch_as_01180", # NNLO, perturbative charm - # "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c - ] - for name in pdf_names: - myrunner.evolve_different_q2(name) + + # Pch evolution + name = "NNPDF40_nnlo_pch_as_01180" + q_grid = [1.65, 10, 100] + myrunner.evolve_different_q2(name, q_grid=q_grid) + + # Fitted charm evolution + # pdf_names = { + # "NNPDF40_nnlo_as_01180": [10, 100], # NNLO, fitted charm + # # "210701-n3fit-data-014": [10, 100], # NNLO, fitted charm + EMC F2c + # } + # for name, q_grid in pdf_names.items(): + # myrunner.evolve_different_q2(name, q_low=1.65, q_grid=q_grid) From 0366ed14ba05e6f261a335c4ad48a91d3a92de24 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 8 Nov 2021 12:48:35 +0100 Subject: [PATCH 62/71] Adding plot_bench to ekonavigator --- benchmarks/ekomark/navigator/__init__.py | 1 + benchmarks/ekomark/navigator/navigator.py | 103 ++++++++++++++++++++++ benchmarks/runners/NNPDF_bench.py | 11 +++ benchmarks/runners/eko_bench.py | 80 +++++++++++++++++ 4 files changed, 195 insertions(+) create mode 100644 benchmarks/runners/eko_bench.py diff --git a/benchmarks/ekomark/navigator/__init__.py b/benchmarks/ekomark/navigator/__init__.py index dbd5900a2..331c12757 100755 --- a/benchmarks/ekomark/navigator/__init__.py +++ b/benchmarks/ekomark/navigator/__init__.py @@ -48,6 +48,7 @@ def yelp(*args): plot_pdfs = app.plot_pdfs display_pdfs = app.display_pdfs compare = app.compare_external +plot_bench = app.plot_eko_bench def launch_navigator(): diff --git a/benchmarks/ekomark/navigator/navigator.py b/benchmarks/ekomark/navigator/navigator.py index 62b610c6a..63260ede7 100644 --- a/benchmarks/ekomark/navigator/navigator.py +++ b/benchmarks/ekomark/navigator/navigator.py @@ -3,10 +3,12 @@ import webbrowser import matplotlib.pyplot as plt +import numpy as np import pandas as pd from banana import navigator as bnav from banana.data import dfdict from matplotlib.backends.backend_pdf import PdfPages +from matplotlib import use, rc from eko import basis_rotation as br @@ -18,6 +20,10 @@ table_objects = bnav.table_objects table_objects["o"] = db.Operator +use("PDF") +rc("font", **{"family": "sans-serif", "sans-serif": ["Helvetica"]}) +rc("text", usetex=True) + class NavigatorApp(bnav.navigator.NavigatorApp): """ @@ -201,6 +207,103 @@ def plot_pdfs(self, doc_hash): return path + def plot_eko_bench( + self, + hashes, + pid, + plot_reldiff=False, + plot_log_only=True, + linestyle="x", + fontsize=18, + rlim=1e-1, + alim=1e-1, + linthresh=1e-5, + ): + """ + Plot the absolute and relative difference of eko results and an external program + for a given pdf element (evolution or flavor basis) + + Parameters + ---------- + hashes : list + log hash list to plot + pid : str + pdf to compare + plot_reldiff: bool + plot also relative difference + plot_log_only : bool + if True plot only the log-x scale, else also linear is plotted + """ + + nrows = 2 if plot_reldiff else 1 + ncols = 1 if plot_log_only else 2 + fig = plt.figure(figsize=(7 * ncols, 7)) + gs = fig.add_gridspec(nrows, ncols) + + # col=0 has log x, col=1 has linear x + for ncol in np.arange(ncols): + labels = [] + ax = ( + plt.subplot(gs[:-1, ncol]) if plot_reldiff else plt.subplot(gs[:, ncol]) + ) + ax.set_ylim(-alim, alim) + ax.set_yscale("symlog", linthresh=linthresh) + if ncol == 0: + ax.set_ylabel( + r"$x{%s}_{eko} - x{%s}_{ref}$" % (pid, pid), fontsize=fontsize + ) + ax.set_xscale("log") + + # relative diff plot, ranges, labels + if plot_reldiff: + ax_ratio = plt.subplot(gs[-1:, ncol], sharex=ax) + ax_ratio.plot( + np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5 + ) + ax_ratio.set_xlabel(r"$x$", fontsize=fontsize) + ax_ratio.set_ylabel( + r"${%s}_{eko}/{%s}_{ref} - 1$" % (pid, pid), fontsize=fontsize + ) + ax_ratio.set_yscale("symlog", linthresh=linthresh) + ax_ratio.set_ylim(-rlim, rlim) + else: + ax.set_xlabel(r"$x$", fontsize=fontsize) + + # loop on logs and plot + log_name = "" + for external_label, h in zip(["LHA", "PEGASUS", "APFEL"],hashes): + log = self.get(bnav.l, h) + log_name += f"{log['hash'][: self.hash_len]}_" + df = log["log"][pid] + external = log["external"] + ax.plot(df.x, df.eko - df[external], linestyle) + labels.append(r"\rm{%s}" % external_label) + + if plot_reldiff: + ax_ratio.plot(df.x, df.percent_error / 100.0, linestyle) + + # legend and labels + ax.legend(labels, fontsize=12) + ax.plot(np.geomspace(1e-7, 1, 200), np.zeros(200), "k--", alpha=0.5) + ax.set_xlim(df.x.min(), 1) + ax.set_title( + r"$x{%s}(x, Q = %s \rightarrow %s\ GeV)$" + % ( + pid, + np.round(self.get(bnav.t, log["t_hash"])["Q0"], 3), + np.sqrt(df.Q2[0]), + ), + fontsize=fontsize, + ) + + # save + path = banana_cfg["database_path"].parents[0] / f"{log_name}{pid}.pdf" + print(f"Writing pdf plots to {path}") + plt.tight_layout() + with PdfPages(path) as pp: + pp.savefig() + plt.close(fig) + def display_pdfs(self, doc_hash): """ Display PDF generated by ekomark.navigator.navigator.plot_pdfs diff --git a/benchmarks/runners/NNPDF_bench.py b/benchmarks/runners/NNPDF_bench.py index 75df0bcca..7c5bb99c9 100644 --- a/benchmarks/runners/NNPDF_bench.py +++ b/benchmarks/runners/NNPDF_bench.py @@ -83,6 +83,16 @@ def benchmark_nnlo(self, Q0=1.65, Q2grid=(100,)): operator_card = {**base_operator, "Q2grid": list(Q2grid)} self.run([theory_card], [operator_card], ["NNPDF40_nnlo_as_01180"]) + def benchmark_pch(self, Q0=1.5, Q2grid=(1.65 ** 2,)): + theory_card = { + **base_theory, + "PTO": 2, + "Q0": Q0, + } + + operator_card = {**base_operator, "Q2grid": list(Q2grid)} + self.run([theory_card], [operator_card], ["NNPDF40_nnlo_pch_as_01180"]) + if __name__ == "__main__": # nn31 = BenchmarkNNPDF31() @@ -95,3 +105,4 @@ def benchmark_nnlo(self, Q0=1.65, Q2grid=(100,)): nn40 = BenchmarkNNPDF40() # nn40.benchmark_nlo(Q2grid=[100]) nn40.benchmark_nnlo(Q2grid=[100]) + # nn40.benchmark_pch() diff --git a/benchmarks/runners/eko_bench.py b/benchmarks/runners/eko_bench.py new file mode 100644 index 000000000..3f8a1d433 --- /dev/null +++ b/benchmarks/runners/eko_bench.py @@ -0,0 +1,80 @@ +# -*- coding: utf-8 -*- +""" +Run multiple eko benchmarks with the same VFNS settings (as LHA) +and and a fine grid +""" +import numpy as np + +from ekomark.benchmark.runner import Runner +from eko.interpolation import make_lambert_grid + +base_theory = { + "ModEv": "EXA", + "Q0": np.sqrt( + 2.0 + ), # Eq. (30) :cite:`Giele:2002hx`, Eq. (4.53) :cite:`Dittmar:2005ed` + "nfref": 3, + "mc": np.sqrt( + 2.0 + ), # Eq. (34) :cite:`Giele:2002hx`, Eq. (4.56) :cite:`Dittmar:2005ed` + "mb": 4.5, + "mt": 175.0, + "Qref": np.sqrt( + 2.0 + ), # Eq. (32) :cite:`Giele:2002hx`,Eq. (4.53) :cite:`Dittmar:2005ed` + "alphas": 0.35, # Eq. (4.55) :cite:`Dittmar:2005ed` + "FNS": "ZM-VFNS", # ignored by eko, but needed by LHA_utils + # TODO: fix this with merging with develop ( not now, will screw db ... ) + # "nf0": 3, + "kcThr": 1.0 + 1e-15, # here you need to start in nf=3 and do the match. + "kbThr": 1.0, + "ktThr": 1.0, +} +"""Global theory settings""" + + +class BenchmarkRunner(Runner): + """ + Generic benchmark runner using the LHA VFNS settings + """ + + def __init__(self, external): + super().__init__() + self.external = external + self.theory = base_theory + self.sandbox = True + self.rotate_to_evolution_basis = True + + def skip_pdfs(self, _theory): + return [22, -6, 6, "ph", "V35", "V24", "V15", "V8", "T35"] + + def doit(self, pto): + """ + Enforce operators and PDF + + Parameters + ---------- + pto : int + perturbation order + """ + th = self.theory.copy() + th.update({"PTO": pto}) + self.run( + [th], + [ + { + "Q2grid": [1e4], + "ev_op_iterations": 100, + "interpolation_xgrid": make_lambert_grid(150).tolist(), + } + ], + ["ToyLH"], + ) + + +if __name__ == "__main__": + + programs = ["LHA", "pegasus", "apfel"] + for p in programs: + obj = BenchmarkRunner(p) + obj.doit(2) From 1cd30ae9aec82793afae59d43129dae177485530 Mon Sep 17 00:00:00 2001 From: Giacomo Magni Date: Mon, 8 Nov 2021 15:08:34 +0100 Subject: [PATCH 63/71] Small fixes on navigators --- backward_paper/navigator.py | 2 ++ benchmarks/ekomark/navigator/navigator.py | 4 ++-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/backward_paper/navigator.py b/backward_paper/navigator.py index 8103aa61c..1dd65b58a 100644 --- a/backward_paper/navigator.py +++ b/backward_paper/navigator.py @@ -71,6 +71,8 @@ def search_label(self, log, key): label = log["pdf"] if label == "210701-n3fit-data-014": label = "NNPDF40_nnlo_as_01180_w_EMC" + elif key == "external": + label = log["external"] elif key is not None: try: theory = self.get(bnav.t, log["t_hash"]) diff --git a/benchmarks/ekomark/navigator/navigator.py b/benchmarks/ekomark/navigator/navigator.py index 63260ede7..3600cc3ba 100644 --- a/benchmarks/ekomark/navigator/navigator.py +++ b/benchmarks/ekomark/navigator/navigator.py @@ -271,13 +271,13 @@ def plot_eko_bench( # loop on logs and plot log_name = "" - for external_label, h in zip(["LHA", "PEGASUS", "APFEL"],hashes): + for h in hashes: log = self.get(bnav.l, h) log_name += f"{log['hash'][: self.hash_len]}_" df = log["log"][pid] external = log["external"] ax.plot(df.x, df.eko - df[external], linestyle) - labels.append(r"\rm{%s}" % external_label) + labels.append(r"\rm{%s}" % external) if plot_reldiff: ax_ratio.plot(df.x, df.percent_error / 100.0, linestyle) From d1086a7a8db84a1b5ddadfcd2cc99d5f9e61c218 Mon Sep 17 00:00:00 2001 From: Giacomo Magni Date: Wed, 10 Nov 2021 16:18:32 +0100 Subject: [PATCH 64/71] Add mass and dataset variation to evolve backward --- backward_paper/evolve_backward.py | 57 +++++++++++++++++++++++++++---- 1 file changed, 50 insertions(+), 7 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 32aab95a6..40eb2a049 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -6,7 +6,7 @@ from ekomark.data import operators -# from eko.interpolation import make_grid, make_lambert_grid +from eko.interpolation import make_lambert_grid from runner import BackwardPaperRunner @@ -36,6 +36,7 @@ class BackwardRunner(BackwardPaperRunner): "ModEv": "EXA", } base_operator = { + "interpolation_xgrid": [make_lambert_grid(60, x_min=1e-3).tolist()], # "interpolation_xgrid": [np.linspace(1e-2,1,50)], # "interpolation_xgrid": [make_grid(30,10).tolist()], # "interpolation_xgrid": [make_lambert_grid(50).tolist()], @@ -135,6 +136,29 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): operator_updates["backward_inversion"] = ["exact", "expanded"] self.doit(pdf_name, operator_updates, q_high=q_high, q_low=q_low) + def evolve_backward_mass_variation( + self, pdf_name, q_high=1.65, charm_mass=1.51, epsilon=0.01 + ): + """ + Backward evolution changing also the charm mass value + (the final Q scale is set to charm mass - epsilon) + + Parameters + ---------- + pdf_name: str + PDF name + q_high: float + initial Q scale + charm_mass: float + charm mass + """ + operator_updates = self.base_operator.copy() + theory_updates = self.base_theory.copy() + theory_updates["mc"] = charm_mass + q_low = charm_mass - epsilon + self.fig_name = None + return self.doit(pdf_name, operator_updates, theory_updates, q_high, q_low) + if __name__ == "__main__": @@ -144,13 +168,12 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): pdf_names = [ "NNPDF40_nnlo_as_01180", # NNLO, fitted charm # "NNPDF40_nnlo_pch_as_01180", # NNLO, perturbative charm - # "210701-n3fit-data-014", # NNLO, fitted charm + EMC F2c # "210701-n3fit-meth-013", # NNPDF4.0 in flavour basis ] - for name in pdf_names: + # for name in pdf_names: - # Simple inversion - myrunner.evolve_backward(name) + # # Simple inversion + # myrunner.evolve_backward(name) # # Test beclow above thr # myrunner.evolve_above_below_thr(name) @@ -167,9 +190,29 @@ def evolve_exact_expanded(self, pdf_name, q_high=1.65, q_low=1.5): # myrunner.evolve_backward(pdf_name, q_low=5, q_high=4.91, return_to_Q0=True) # myrunner.evolve_backward(pdf_name, q_low=4.91, q_high=5, return_to_Q0=True) - # forward matching - # q_low = 1.51 to compare with Silvia's plot + # # pch vs ic forward matching + # # q_low = 1.51 to compare with Silvia's plot # pdf_name = "NNPDF40_nnlo_pch_as_01180" # myrunner.evolve_backward(pdf_name, q_low=1.51, q_high=1.5, return_to_Q0=False) # pdf_name = "NNPDF40_nnlo_as_01180" # myrunner.evolve_backward(pdf_name, q_low=1.5101, q_high=1.65, return_to_Q0=False) + + # # charm mass variations + # mass_variations = { + # 1.38: "211103-ern-001", # NNPDF40 baseline with mc=1.38 + # 1.64: "211103-ern-002", # NNPDF40 baseline with mc=1.64 + # } + # for c_m, pdf_name in mass_variations.items(): + # myrunner.evolve_backward_mass_variation(pdf_name, q_high=1.65, charm_mass=c_m) + + # # dataset_variations + # pdf_names =[ + # "NNPDF40_nnlo_as_01180_EMC", # NNPDF40 baseline, fitted charm + EMC F2c + # "NNPDF40_nnlo_as_01180_DIS_only", # NNPDF40 baseline DIS only + # "NNPDF40_nnlo_as_01180_collider_only", # NNPDF40 baseline collider only + # "NNPDF40_nnlo_as_01180_noLHCb", # NNPDF40 baseline no LHCb + # "NNPDF40_nnlo_as_01180", # NNLO, fitted charm + # ] + # for name in pdf_names: + # # Simple inversion + # myrunner.evolve_backward(name) From c32b4f6d4789f0d44c65c6565cb054229089e16b Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 29 Nov 2021 17:28:09 +0100 Subject: [PATCH 65/71] remove unsed h and cs functions --- .../matching_conditions/n3lo/cs_functions.py | 911 --------- .../matching_conditions/n3lo/h_functions.py | 1707 ----------------- tests/test_cs_functions.py | 255 --- 3 files changed, 2873 deletions(-) delete mode 100644 src/eko/matching_conditions/n3lo/cs_functions.py delete mode 100644 src/eko/matching_conditions/n3lo/h_functions.py delete mode 100644 tests/test_cs_functions.py diff --git a/src/eko/matching_conditions/n3lo/cs_functions.py b/src/eko/matching_conditions/n3lo/cs_functions.py deleted file mode 100644 index 4bdeb191a..000000000 --- a/src/eko/matching_conditions/n3lo/cs_functions.py +++ /dev/null @@ -1,911 +0,0 @@ -# -*- coding: utf-8 -*- -"""This module contains some approximations for generalized harmonics sum""" -# import numba as nb -import numpy as np -import mpmath as mp -from ...anomalous_dimensions.harmonics import zeta2, zeta3 - -ln2 = np.log(2) - -# @nb.njit("c16(c16)", cache=True) -def S111l211(H22, H24): - return complex(H24 + H22) - - -# @nb.njit("c16(c16)", cache=True) -def S12l21(H25): - return complex(2.0 * H25) - - -# @nb.njit("c16(c16,c16)", cache=True) -def S1111l20511(n, S1): - return complex( - -1.9723041257941845 - - 0.08333333333333336 / (4.0 + n) - + 36.70520952439886 / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n)) - + (51.3872933341584 * n) / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n)) - + (22.023125714639317 * np.power(n, 2)) - / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n)) - + (2.9364167619519086 * np.power(n, 3)) - / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n)) - + 0.5570208571546438 / (5.0 + n) - + 0.47368752382131046 / (6.0 + n) - + 0.404243079376866 / (7.0 + n) - + 0.3472986349324216 / (8.0 + n) - + 0.3005104404879771 / (9.0 + n) - + 0.26170973502060496 / (10.0 + n) - + 0.22915021121108117 / (11.0 + n) - + 0.20149148105235104 / (12.0 + n) - + 0.1777199863433563 / (13.0 + n) - + 0.15706943319280317 / (14.0 + n) - + 0.13895637231188515 / (15.0 + n) - + 0.12293186353142399 / (16.0 + n) - + 0.10864628686024465 / (17.0 + n) - + 0.09582397689507753 / (18.0 + n) - + 0.08424493020690386 / (19.0 + n) - + 0.07373153305835264 / (20.0 + n) - + 0.06413884299411146 / (21.0 + n) - + 0.05534739575263509 / (22.0 + n) - + 0.047257820113419974 / (23.0 + n) - + 0.03978675952632231 / (24.0 + n) - + 0.03286374838430062 / (25.0 + n) - + 0.02642879344355784 / (26.0 + n) - + 0.02043048189300573 / (27.0 + n) - + 0.014824487031234552 / (28.0 + n) - + 0.009572377262420904 / (29.0 + n) - + 0.004640658782124118 / (30.0 + n) - + 0.7341041904879771 * S1 - + 0.9015426773696957 * n * mp.hyper([1.0, 1.0, 1.0 - 1.0 * n], [2.0, 2.0], -1.0) - ) - - -# @nb.njit("c16(c16)", cache=True) -def S1l05(n): - return complex(ln2 - 1.0 * mp.betainc(1.0 + n, 0.0, x2=0.5)) - - -# @nb.njit("c16(c16,c16,c16,c16)", cache=True) -def S31l205(n, S1, S2, S3): - # HarmonicNumber[5. +N] - Snp5 = (274 + 450 * n + 255 * n ** 2 + 60 * n ** 3 + 5 * n ** 4) / ( - (1 + n) * (2 + n) * (3 + n) * (4 + n) * (5 + n) - ) + S1 - # Mellin[PolyLog[3,x/2]/(-1+x)] - H29 = ( - -0.557968 - + 1 / (-4 - 2 * n) - - 0.53125 / (3 + n) - - 0.53588 / (4 + n) - - 0.536856 / (5 + n) - + 0.537106 * Snp5 - ) - return ( - H29 - - 1.0 / 6.0 * ln2 ** 3 * S1 - + 1.0 / 2.0 * ln2 * zeta2 * S1 - - 7.0 / 8.0 * zeta3 * S1 - - 1.0 / 2.0 * ln2 ** 2 * S2 - + 1.0 / 2.0 * zeta2 * S2 - - ln2 * S3 - + ln2 * S3l2(n) - ) - - -# @nb.njit("c16(c16,c16,c16)", cache=True) -def S121l2051(n, S1, H23): - # HarmonicNumber S[1,N+15] - Hp15 = ( - 4339163001600 - + 12331635229440 * n - + 15170987111472 * n ** 2 - + 10827253382400 * n ** 3 - + 5048360535400 * n ** 4 - + 1636819264080 * n ** 5 - + 382417906871 * n ** 6 - + 65661024000 * n ** 7 - + 8352861660 * n ** 8 - + 785584800 * n ** 9 - + 53895842 * n ** 10 - + 2620800 * n ** 11 - + 85540 * n ** 12 - + 1680 * n ** 13 - + 15 * n ** 14 - ) / ( - (1 + n) - * (2 + n) - * (3 + n) - * (4 + n) - * (5 + n) - * (6 + n) - * (7 + n) - * (8 + n) - * (9 + n) - * (10 + n) - * (11 + n) - * (12 + n) - * (13 + n) - * (14 + n) - * (15 + n) - ) + S1 - return complex( - -1.6449340668482262 * H23 - - ( - -1.0970571006583727e12 - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (1.9125237074510933e12 * n) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (1.4994381266170989e12 * np.power(n, 2)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (7.009994340470765e11 * np.power(n, 3)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (2.183094685920398e11 * np.power(n, 4)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (4.787984810093941e10 * np.power(n, 5)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (7.616207507383221e9 * np.power(n, 6)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (8.904886102155218e8 * np.power(n, 7)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (7.659214612862481e7 * np.power(n, 8)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (4.790018361468757e6 * np.power(n, 9)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (211858.07625410164 * np.power(n, 10)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (6279.1827747379675 * np.power(n, 11)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (111.83851326006433 * np.power(n, 12)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - - (0.9044729718388043 * np.power(n, 13)) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (3.3061524774118085e11 * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (6.011342290466014e11 * n * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (4.9187554395002936e11 * np.power(n, 2) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (2.401640821300795e11 * np.power(n, 3) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (7.817131339252147e10 * np.power(n, 4) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (1.7933250800932724e10 * np.power(n, 5) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (2.986455305719683e9 * np.power(n, 6) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (3.659103962777948e8 * np.power(n, 7) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (3.3015840269221872e7 * np.power(n, 8) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (2.1686039669867153e6 * np.power(n, 9) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (100870.34556855283 * np.power(n, 10) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (3148.7061275553474 * np.power(n, 11) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (59.16149300208377 * np.power(n, 12) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + (0.5056537863425963 * np.power(n, 13) * Hp15) - / ( - (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - ) - + 0.631966197838168 - * n - * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) - ) - - -# @nb.njit("c16(c16,c16)", cache=True) -def S21l21(n, S1): - return complex( - ( - complex(1.6833606003593822e27, 2.1316401151124944e27) - - 1.6833606028664177e27 * np.power(2.0, n) - + complex(1.1280238519747306e28, 1.4284014544217873e28) * n - - 9.793413137165368e27 * np.power(2.0, n) * n - + complex(3.5133648703234346e28, 4.4489029733809166e28) * np.power(n, 2) - - 2.6584983157605467e28 * np.power(2.0, n) * np.power(n, 2) - + complex(6.7936790083925e28, 8.602679035475088e28) * np.power(n, 3) - - 4.500022047614448e28 * np.power(2.0, n) * np.power(n, 3) - + complex(9.19012141317016e28, 1.1637229431490278e29) * np.power(n, 4) - - 5.351614784848519e28 * np.power(2.0, n) * np.power(n, 4) - + complex(9.2890946632445e28, 1.1762554569358886e29) * np.power(n, 5) - - 4.774123285176482e28 * np.power(2.0, n) * np.power(n, 5) - + complex(7.314978363595366e28, 9.262779365216703e28) * np.power(n, 6) - - 3.3296016110218174e28 * np.power(2.0, n) * np.power(n, 6) - + complex(4.618995743047189e28, 5.848922626855809e28) * np.power(n, 7) - - 1.867555495886855e28 * np.power(2.0, n) * np.power(n, 7) - + complex(2.3881423804543337e28, 3.024047281480256e28) * np.power(n, 8) - - 8.598161226007345e27 * np.power(2.0, n) * np.power(n, 8) - + complex(1.027023747870955e28, 1.3004956199394855e28) * np.power(n, 9) - - 3.299192196302645e27 * np.power(2.0, n) * np.power(n, 9) - + complex(3.718430053139092e27, 4.708559564429205e27) * np.power(n, 10) - - 1.0673974911524395e27 * np.power(2.0, n) * np.power(n, 10) - + complex(1.1441604044899806e27, 1.4488232559998715e27) * np.power(n, 11) - - 2.9379890367598923e26 * np.power(2.0, n) * np.power(n, 11) - + complex(3.014106578187488e26, 3.816692213649815e26) * np.power(n, 12) - - 6.927509956951886e25 * np.power(2.0, n) * np.power(n, 12) - + complex(6.836865750537136e25, 8.657362927743468e25) * np.power(n, 13) - - 1.4066600113346826e25 * np.power(2.0, n) * np.power(n, 13) - + complex(1.3411340313136578e25, 1.6982467451739608e25) * np.power(n, 14) - - 2.4692772904714515e24 * np.power(2.0, n) * np.power(n, 14) - + complex(2.2823563954140286e24, 2.890094902276634e24) * np.power(n, 15) - - 3.757351574332791e23 * np.power(2.0, n) * np.power(n, 15) - + complex(3.3768613922826975e23, 4.276041487375118e23) * np.power(n, 16) - - 4.963794071544808e22 * np.power(2.0, n) * np.power(n, 16) - + complex(4.348682972736758e22, 5.506637080449338e22) * np.power(n, 17) - - 5.696446468351613e21 * np.power(2.0, n) * np.power(n, 17) - + complex(4.875275445814089e21, 6.173449430059735e21) * np.power(n, 18) - - 5.67601106161025e20 * np.power(2.0, n) * np.power(n, 18) - + complex(4.754442901083716e20, 6.020442354673485e20) * np.power(n, 19) - - 4.902928615262456e19 * np.power(2.0, n) * np.power(n, 19) - + complex(4.0260266191939265e19, 5.098065797780899e19) * np.power(n, 20) - - 3.661480489217735e18 * np.power(2.0, n) * np.power(n, 20) - + complex(2.951591241364906e18, 3.7375329856855946e18) * np.power(n, 21) - - 2.354412432066986e17 * np.power(2.0, n) * np.power(n, 21) - + complex(1.8655124802380563e17, 2.3622562465222666e17) * np.power(n, 22) - - 1.296218655332279e16 * np.power(2.0, n) * np.power(n, 22) - + complex(1.0106075448696164e16, 1.2797095428905186e16) * np.power(n, 23) - - 6.06359582313501e14 * np.power(2.0, n) * np.power(n, 23) - + complex(4.6562817914004075e14, 5.896144952336889e14) * np.power(n, 24) - - 2.385660927511548e13 * np.power(2.0, n) * np.power(n, 24) - + complex(1.805881124487301e13, 2.286746791927984e13) * np.power(n, 25) - - 7.786891093408528e11 * np.power(2.0, n) * np.power(n, 25) - + complex(5.814854720381085e11, 7.363220583644232e11) * np.power(n, 26) - - 2.0694973396132874e10 * np.power(2.0, n) * np.power(n, 26) - + complex(1.5255184441562937e10, 1.93173001082478e10) * np.power(n, 27) - - 4.361551307055125e8 * np.power(2.0, n) * np.power(n, 27) - + complex(3.1755495944092846e8, 4.021127881543603e8) * np.power(n, 28) - - 7.009322268197093e6 * np.power(2.0, n) * np.power(n, 28) - + complex(5.043047411303078e6, 6.385899164941185e6) * np.power(n, 29) - - 80650.58350683903 * np.power(2.0, n) * np.power(n, 29) - + complex(57364.741155652126, 72639.7036051468) * np.power(n, 30) - - 591.4373566195608 * np.power(2.0, n) * np.power(n, 30) - + complex(416.0214728560528, 526.7988174426441) * np.power(n, 31) - - 2.076022092268843 * np.power(2.0, n) * np.power(n, 31) - + complex(1.4445189418954867, 1.8291625605647361) * np.power(n, 32) - + 1.9169483570505036e27 * S1 - + 1.2845375736034561e28 * n * S1 - + 4.000824147114336e28 * np.power(n, 2) * S1 - + 7.736245591539027e28 * np.power(n, 3) * S1 - + 1.046516608556964e29 * np.power(n, 4) * S1 - + 1.0577868889120365e29 * np.power(n, 5) * S1 - + 8.329862794375306e28 * np.power(n, 6) * S1 - + 5.259838441103391e28 * np.power(n, 7) * S1 - + 2.7194752185317597e28 * np.power(n, 8) * S1 - + 1.1695139926857725e28 * np.power(n, 9) * S1 - + 4.2343289831692154e27 * np.power(n, 10) * S1 - + 1.302902558717772e27 * np.power(n, 11) * S1 - + 3.43228756883164e26 * np.power(n, 12) * S1 - + 7.785421902632924e25 * np.power(n, 13) * S1 - + 1.527204937150373e25 * np.power(n, 14) * S1 - + 2.599014080923719e24 * np.power(n, 15) * S1 - + 3.845372699542644e23 * np.power(n, 16) * S1 - + 4.952026765401563e22 * np.power(n, 17) * S1 - + 5.551679975614853e21 * np.power(n, 18) * S1 - + 5.4140832679439185e20 * np.power(n, 19) * S1 - + 4.584605434053637e19 * np.power(n, 20) * S1 - + 3.3611009970855055e18 * np.power(n, 21) * S1 - + 2.1243375927292365e17 * np.power(n, 22) * S1 - + 1.1508214207239058e16 * np.power(n, 23) * S1 - + 5.302304689793915e14 * np.power(n, 24) * S1 - + 2.0564332012233316e13 * np.power(n, 25) * S1 - + 6.621621304810342e11 * np.power(n, 26) * S1 - + 1.737172538770829e10 * np.power(n, 27) * S1 - + 3.616133150885176e8 * np.power(n, 28) * S1 - + 5.742732474275174e6 * np.power(n, 29) * S1 - + 65323.672366324005 * np.power(n, 30) * S1 - + 473.74137896608875 * np.power(n, 31) * S1 - + 1.644935343632253 * np.power(n, 32) * S1 - + np.power(2.0, n) - * ( - 1.3570442448525208e27 - + 7.736441842782683e27 * n - + 2.0586154139209478e28 * np.power(n, 2) - + 3.418020155394567e28 * np.power(n, 3) - + 3.990470196270089e28 * np.power(n, 4) - + 3.497804616136419e28 * np.power(n, 5) - + 2.3990638748389658e28 * np.power(n, 6) - + 1.3244759164655748e28 * np.power(n, 7) - + 6.006923754991886e27 * np.power(n, 8) - + 2.2722885003172314e27 * np.power(n, 9) - + 7.25273617768887e26 * np.power(n, 10) - + 1.9707591366660945e26 * np.power(n, 11) - + 4.590225915847702e25 * np.power(n, 12) - + 9.212225005158819e24 * np.power(n, 13) - + 1.5991495582075087e24 * np.power(n, 14) - + 2.4074200060054864e23 * np.power(n, 15) - + 3.1479255232159525e22 * np.power(n, 16) - + 3.577085214505872e21 * np.power(n, 17) - + 3.530547563815296e20 * np.power(n, 18) - + 3.0218507756908265e19 * np.power(n, 19) - + 2.2367871200740178e18 * np.power(n, 20) - + 1.4260027848947278e17 * np.power(n, 21) - + 7.785624904017476e15 * np.power(n, 22) - + 3.612590748983618e14 * np.power(n, 23) - + 1.4101170841935729e13 * np.power(n, 24) - + 4.5671137945917285e11 * np.power(n, 25) - + 1.2045801726015282e10 * np.power(n, 26) - + 2.519734716536869e8 * np.power(n, 27) - + 4.019480007235419e6 * np.power(n, 28) - + 45909.66551176623 * np.power(n, 29) - + 334.2060621909171 * np.power(n, 30) - + 1.164481052930025 * np.power(n, 31) - ) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - + n - * ( - 1.9169468691324218e27 - + 1.2845365765569392e28 * n - + 4.000821041710599e28 * np.power(n, 2) - + 7.736239586734746e28 * np.power(n, 3) - + 1.0465157962601805e29 * np.power(n, 4) - + 1.0577860678673627e29 * np.power(n, 5) - + 8.329856328810687e28 * np.power(n, 6) - + 5.259834358464076e28 * np.power(n, 7) - + 2.7194731076995423e28 * np.power(n, 8) - + 1.1695130849195251e28 * np.power(n, 9) - + 4.2343256965211237e27 * np.power(n, 10) - + 1.302901547416519e27 * np.power(n, 11) - + 3.4322849047208846e26 * np.power(n, 12) - + 7.785415859658431e25 * np.power(n, 13) - + 1.52720375174763e25 * np.power(n, 14) - + 2.5990120635923536e24 * np.power(n, 15) - + 3.845369714798924e23 * np.power(n, 16) - + 4.9520229216829045e22 * np.power(n, 17) - + 5.551675666450765e21 * np.power(n, 18) - + 5.414079065581157e20 * np.power(n, 19) - + 4.584601875524113e19 * np.power(n, 20) - + 3.361098388229127e18 * np.power(n, 21) - + 2.1243359438374944e17 * np.power(n, 22) - + 1.1508205274666648e16 * np.power(n, 23) - + 5.302300574192681e14 * np.power(n, 24) - + 2.0564316050383676e13 * np.power(n, 25) - + 6.621616165167411e11 * np.power(n, 26) - + 1.737171190393121e10 * np.power(n, 27) - + 3.6161303440751326e8 * np.power(n, 28) - + 5.742728016817852e6 * np.power(n, 29) - + 65323.62166267675 * np.power(n, 30) - + 473.7410112522892 * np.power(n, 31) - + 1.6449340668482266 * np.power(n, 32) - ) - * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) - ) - / ( - np.power(1.0 + n, 2) - * np.power(2.0 + n, 2) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - * np.power(10.0 + n, 2) - * np.power(11.0 + n, 2) - * np.power(12.0 + n, 2) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - * (16.0 + n) - * (17.0 + n) - * (18.0 + n) - * (19.0 + n) - * (20.0 + n) - ) - ) - - -# @nb.njit("c16(c16,c16,c16)", cache=True) -def S1111l21051(n, S1, H21): - return complex( - ( - complex(0.00008138020833333333, 0.00011869952602801132) - - complex(1.1108200333002769e12, 0.000021919931066000538) * n - - complex(3.0545253221968545e12, 0.000416485473072374) * np.power(n, 2) - - complex(3.746669508953097e12, 0.0005080718865495499) * np.power(n, 3) - - complex(2.732663230220466e12, 0.00037230189267925355) * np.power(n, 4) - - complex(1.3303092958914858e12, 0.00019969252622130892) * np.power(n, 5) - - complex(4.592245894160175e11, 0.00007079577081180635) * np.power(n, 6) - - complex(1.1640732704756241e11, 0.000015694489505731582) * np.power(n, 7) - - complex(2.2109629870529408e10, 2.5755745976631705e-6) * np.power(n, 8) - - complex(3.1780932871117997e9, 4.259823137078089e-7) * np.power(n, 9) - - complex(3.4627926147031265e8, 5.3381447021793165e-8) * np.power(n, 10) - - complex(2.84068280075561e7, 3.5211097252823663e-9) * np.power(n, 11) - - complex(1.72524518874892e6, 2.480870637667729e-10) * np.power(n, 12) - - complex(75180.21417891773, 2.672155268808036e-12) * np.power(n, 13) - - complex(2221.544934523533, 3.024184544294806e-13) * np.power(n, 14) - - 39.8447173169642 * np.power(n, 15) - - 0.3272966537768275 * np.power(n, 16) - + H21 - * ( - -4.302076232534848e12 - - 1.53507931440122e13 * n - - 2.3853545410321223e13 * np.power(n, 2) - - 2.170803074046334e13 * np.power(n, 3) - - 1.3064271224116332e13 * np.power(n, 4) - - 5.547952832953075e12 * np.power(n, 5) - - 1.7279086122273728e12 * np.power(n, 6) - - 4.041008596208101e11 * np.power(n, 7) - - 7.193431686649904e10 * np.power(n, 8) - - 9.803816052654116e9 * np.power(n, 9) - - 1.0217751899949871e9 * np.power(n, 10) - - 8.073087028086561e7 * np.power(n, 11) - - 4.748284771638826e6 * np.power(n, 12) - - 201274.13241954896 * np.power(n, 13) - - 5806.617255974238 * np.power(n, 14) - - 101.98591214459 * np.power(n, 15) - - 0.8224670334241131 * np.power(n, 16) - ) - + complex(7.708392419040001e11, 0.00009449713909064082) * S1 - + complex(2.7505309320805107e12, 0.0003858633179534501) * n * S1 - + complex(4.2740406880192827e12, 0.0006260435464754956) - * np.power(n, 2) - * S1 - + complex(3.8896107494933716e12, 0.0005118595034076379) - * np.power(n, 3) - * S1 - + complex(2.3408355366339976e12, 0.0002323054669311587) - * np.power(n, 4) - * S1 - + complex(9.940734484272197e11, 0.00007481023511342399) - * np.power(n, 5) - * S1 - + complex(3.0960394301147516e11, 0.000027684708717961177) - * np.power(n, 6) - * S1 - + complex(7.24061554109936e10, 0.000010043397107127028) - * np.power(n, 7) - * S1 - + complex(1.2889077571640892e10, 2.3570453394597503e-6) - * np.power(n, 8) - * S1 - + complex(1.7566323154951086e9, 3.441363097579897e-7) * np.power(n, 9) * S1 - + complex(1.8308006885037723e8, 3.4608702131655363e-8) - * np.power(n, 10) - * S1 - + complex(1.4465230154437648e7, 1.9284163711165284e-9) - * np.power(n, 11) - * S1 - + complex(850790.1849888319, 4.107008214012321e-12) * np.power(n, 12) * S1 - + complex(36063.98196197322, 1.1734309182892347e-12) * np.power(n, 13) * S1 - + complex(1040.4205322471842, 1.1734309182892347e-13) * np.power(n, 14) * S1 - + 18.27367507063043 * np.power(n, 15) * S1 - + 0.14736834734379375 * np.power(n, 16) * S1 - + n - * ( - -2.196022510565852e12 - - 7.835911191984595e12 * n - - 1.2176195828823182e13 * np.power(n, 2) - - 1.1081004052321111e13 * np.power(n, 3) - - 6.668741356866405e12 * np.power(n, 4) - - 2.831988242464008e12 * np.power(n, 5) - - 8.820220757492529e11 * np.power(n, 6) - - 2.062758854794705e11 * np.power(n, 7) - - 3.671933517271283e10 * np.power(n, 8) - - 5.004421023099778e9 * np.power(n, 9) - - 5.2157172413576376e8 * np.power(n, 10) - - 4.1209592497130744e7 * np.power(n, 11) - - 2.4237925321355704e6 * np.power(n, 12) - - 102741.67673860745 * np.power(n, 13) - - 2964.0251625309274 * np.power(n, 14) - - 52.059365460883136 * np.power(n, 15) - - 0.419833592426477 * np.power(n, 16) - ) - * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * np.power(4.0 + n, 2) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - ) - - -# @nb.njit("c16(c16)", cache=True) -def S3l2(n): - return complex( - 2.0 * ((1.38104 - 0.377347j) - 2 ** n * mp.lerchphi(2.0, 3.0, 1.0 + n)) - ) diff --git a/src/eko/matching_conditions/n3lo/h_functions.py b/src/eko/matching_conditions/n3lo/h_functions.py deleted file mode 100644 index 32910cb95..000000000 --- a/src/eko/matching_conditions/n3lo/h_functions.py +++ /dev/null @@ -1,1707 +0,0 @@ -# -*- coding: utf-8 -*- -# pylint: disable=too-many-lines -"""This module contains some Mellin transform used for in the generalized haromonic sums. -Mellin transform is defined with the convention x^(n) -""" -import numba as nb -import numpy as np -import mpmath as mp - -# @nb.njit("c16(c16,c16)", cache=True) -def H21(n, S1): - r"""Mellin transform of :math:`\int_{1}^{2} (x^(n)-1)(ln(1-x/2))/(x-1)`""" - return complex( - complex(-2.4674011002723395, -2.177586090303602) * (-1.0 + np.power(2.0, n)) - - 1.0 - * np.power(2.0, n) - * n - * ( - -0.00017861624734509784 - - (18.448868614597806 * (1.0 - 1.0 * np.power(2.0, -1.0 - 1.0 * n))) - / (1.0 + n) - + (53.03705951583224 * (1.0 - 1.0 * np.power(2.0, -2.0 - 1.0 * n))) - / (2.0 + n) - - (72.59017758173087 * (1.0 - 1.0 * np.power(2.0, -3.0 - 1.0 * n))) - / (3.0 + n) - + (48.721104697124765 * (1.0 - 1.0 * np.power(2.0, -4.0 - 1.0 * n))) - / (4.0 + n) - - (11.36436613468647 * (1.0 - 1.0 * np.power(2.0, -5.0 - 1.0 * n))) - / (5.0 + n) - - (8.388218542825193 * (1.0 - 1.0 * np.power(2.0, -6.0 - 1.0 * n))) - / (6.0 + n) - + (16.758614450512397 * (1.0 - 1.0 * np.power(2.0, -7.0 - 1.0 * n))) - / (7.0 + n) - - (22.231044375187043 * (1.0 - 1.0 * np.power(2.0, -8.0 - 1.0 * n))) - / (8.0 + n) - + (22.160106312069402 * (1.0 - 1.0 * np.power(2.0, -9.0 - 1.0 * n))) - / (9.0 + n) - - (15.945856292428402 * (1.0 - 1.0 * np.power(2.0, -10.0 - 1.0 * n))) - / (10.0 + n) - + (7.88216704187177 * (1.0 - 1.0 * np.power(2.0, -11.0 - 1.0 * n))) - / (11.0 + n) - - (2.400714286203908 * (1.0 - 1.0 * np.power(2.0, -12.0 - 1.0 * n))) - / (12.0 + n) - + (0.3429689205921761 * (1.0 - 1.0 * np.power(2.0, -13.0 - 1.0 * n))) - / (13.0 + n) - + ( - 17.066666666666666 - * ( - -1.3862943611198906 * np.power(2.0, -1.0 - 1.0 * n) - + S1 - + mp.betainc(1.0 + n, 0.0, x2=0.5) - ) - ) - / n - - ( - 62.0 - * ( - -1.3862943611198906 * np.power(2.0, -2.0 - 1.0 * n) - + 1 / (1.0 + n) - + S1 - + mp.betainc(2.0 + n, 0.0, x2=0.5) - ) - ) - / (1.0 + n) - + ( - 98.0 - * ( - -1.3862943611198906 * np.power(2.0, -3.0 - 1.0 * n) - + (3.0 + 2.0 * n) / ((1.0 + n) * (2.0 + n)) - + S1 - + mp.betainc(3.0 + n, 0.0, x2=0.5) - ) - ) - / (2.0 + n) - - ( - 82.66666666666667 - * ( - -1.3862943611198906 * np.power(2.0, -4.0 - 1.0 * n) - + (11.0 + 12.0 * n + 3.0 * np.power(n, 2)) - / ((1.0 + n) * (2.0 + n) * (3.0 + n)) - + S1 - + mp.betainc(4.0 + n, 0.0, x2=0.5) - ) - ) - / (3.0 + n) - + ( - 36.0 - * ( - -1.3862943611198906 * np.power(2.0, -5.0 - 1.0 * n) - + (2.0 * (5.0 + 2.0 * n) * (5.0 + 5.0 * n + np.power(n, 2))) - / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n)) - + S1 - + mp.betainc(5.0 + n, 0.0, x2=0.5) - ) - ) - / (4.0 + n) - - ( - 6.4 - * ( - -1.3862943611198906 * np.power(2.0, -6.0 - 1.0 * n) - + ( - 274.0 - + 450.0 * n - + 255.0 * np.power(n, 2) - + 60.0 * np.power(n, 3) - + 5.0 * np.power(n, 4) - ) - / ((1.0 + n) * (2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) - + S1 - + mp.betainc(6.0 + n, 0.0, x2=0.5) - ) - ) - / (5.0 + n) - - ( - 0.6931471805599453 - * ( - complex(0.0, 3.141592653589793) * np.power(2.0, n) - + S1 - + mp.betainc(1.0 + n, 0.0, x2=2.0) - ) - ) - / (np.power(2.0, 1.0 * n) * n) - ) - ) - - -@nb.njit("c16(c16,c16)", cache=True) -def H22(n, S1): - return complex( - -0.09370981275434521 * n - - (0.42787353308023546 * n) / (2.0 + n) - + (0.20524636633955842 * n) / (3.0 + n) - - (0.012972991934051131 * n) / (4.0 + n) - - (0.005763373593698165 * n) / (5.0 + n) - + (0.0009292194616465901 * n) / (6.0 + n) - - (0.0061122598440842245 * n) / (7.0 + n) - + (0.006638305902069104 * n) / (8.0 + n) - - (0.005884194432060406 * n) / (9.0 + n) - + (0.002785480879571394 * n) / (10.0 + n) - - (0.0006792903101534132 * n) / (11.0 + n) - - 0.33739608529577086 * (-1.0 + 1 / (1.0 + n)) - - 0.041666666666666664 - * n - * (-1.606170709478783 - 6.0 / (2.0 + n) + 4.0 / (3.0 + n)) - - 0.01925408834888737 - * n - * (-1.391186796731926 + 30.0 / (1.0 + n) - 3.0 / (2.0 + n) + 4.0 / (3.0 + n)) - + 0.2402265069591007 * S1 - ) - - -@nb.njit("c16(c16,c16)", cache=True) -def H23(n, S1): - r"""Mellin transform of :math:`\int_{0}^{1} (x^(n)-1)(ln(1-x/2))/(x-1)`""" - return complex( - 0.038644077596632104 * n - + (0.17990633019243982 * n) / (2.0 + n) - - (0.08838707737246981 * n) / (3.0 + n) - + (0.006557861587551356 * n) / (4.0 + n) - + (0.0024537382629694544 * n) / (5.0 + n) - - (0.00005974273075922878 * n) / (6.0 + n) - + (0.0018925349638931536 * n) / (7.0 + n) - - (0.0019617338775610098 * n) / (8.0 + n) - + (0.0017680265456417688 * n) / (9.0 + n) - - (0.0008335702736569231 * n) / (10.0 + n) - + (0.00020568989536588186 * n) / (11.0 + n) - + 0.14018613535141447 * (-1.0 + 1 / (1.0 + n)) - - 0.027777777777777776 - * n - * (1.391186796731926 - 30.0 / (1.0 + n) + 3.0 / (2.0 + n) - 4.0 / (3.0 + n)) - - 0.6931471805599453 * S1 - ) - - -def H24(n, S1): - return complex( - complex(2.7620719062289236, 0.7546938294602481) * (-1.0 + np.power(2.0, n)) - - 1.0 - * np.power(2.0, n) - * n - * ( - (6.151252465559908 * (1.0 - 1.0 / np.power(2.0, 1.0 * n))) / n - - (105.96211347491152 * (1.0 - 1.0 * np.power(2.0, -1.0 - 1.0 * n))) - / (1.0 + n) - + (912.428887509948 * (1.0 - 1.0 * np.power(2.0, -2.0 - 1.0 * n))) - / (2.0 + n) - - (4622.246477438636 * (1.0 - 1.0 * np.power(2.0, -3.0 - 1.0 * n))) - / (3.0 + n) - + (15939.451978244468 * (1.0 - 1.0 * np.power(2.0, -4.0 - 1.0 * n))) - / (4.0 + n) - - (39590.27112365593 * (1.0 - 1.0 * np.power(2.0, -5.0 - 1.0 * n))) - / (5.0 + n) - + (72858.10340264498 * (1.0 - 1.0 * np.power(2.0, -6.0 - 1.0 * n))) - / (6.0 + n) - - (100586.39794650947 * (1.0 - 1.0 * np.power(2.0, -7.0 - 1.0 * n))) - / (7.0 + n) - + (104186.07179796268 * (1.0 - 1.0 * np.power(2.0, -8.0 - 1.0 * n))) - / (8.0 + n) - - (79971.67810898797 * (1.0 - 1.0 * np.power(2.0, -9.0 - 1.0 * n))) - / (9.0 + n) - + (44221.656964985224 * (1.0 - 1.0 * np.power(2.0, -10.0 - 1.0 * n))) - / (10.0 + n) - - (16684.086864855977 * (1.0 - 1.0 * np.power(2.0, -11.0 - 1.0 * n))) - / (11.0 + n) - + (3850.0341714476917 * (1.0 - 1.0 * np.power(2.0, -12.0 - 1.0 * n))) - / (12.0 + n) - - (410.4937387157474 * (1.0 - 1.0 * np.power(2.0, -13.0 - 1.0 * n))) - / (13.0 + n) - - ( - 3.8888888888888893 - * ( - -1.3862943611198906 * np.power(2.0, -1.0 - 1.0 * n) - + S1 - + mp.betainc(1.0 + n, 0.0, x2=0.5) - ) - ) - / n - + ( - 6.666666666666667 - * ( - -1.3862943611198906 * np.power(2.0, -2.0 - 1.0 * n) - + 1 / (1.0 + n) - + S1 - + mp.betainc(2.0 + n, 0.0, x2=0.5) - ) - ) - / (1.0 + n) - - ( - 3.666666666666665 - * ( - -1.3862943611198906 * np.power(2.0, -3.0 - 1.0 * n) - + (3.0 + 2.0 * n) / ((1.0 + n) * (2.0 + n)) - + S1 - + mp.betainc(3.0 + n, 0.0, x2=0.5) - ) - ) - / (2.0 + n) - + ( - 0.8888888888888886 - * ( - -1.3862943611198906 * np.power(2.0, -4.0 - 1.0 * n) - + (11.0 + 12.0 * n + 3.0 * np.power(n, 2)) - / ((1.0 + n) * (2.0 + n) * (3.0 + n)) - + S1 - + mp.betainc(4.0 + n, 0.0, x2=0.5) - ) - ) - / (3.0 + n) - + ( - 0.4804530139182014 - * np.power(2.0, -1.0 - 1.0 * n) - * ( - complex(0.0, 3.141592653589793) * np.power(2.0, n) - + S1 - + mp.betainc(1.0 + n, 0.0, x2=2.0) - ) - ) - / n - + 1.3333333333333333 - * ( - 0.6931471805599453 - * ( - ( - 0.6931471805599453 - - 0.6931471805599453 * np.power(2.0, -3.0 - 1.0 * n) - ) - / (3.0 + n) - + mp.hyper(list([1.0, 1.0, -2.0 - 1.0 * n]), list([2.0, 2.0]), 0.5) - ) - + mp.hyper( - list([1.0, 1.0, 1.0, -2.0 - 1.0 * n]), list([2.0, 2.0, 2.0]), 0.5 - ) - ) - - 5.0 - * ( - 0.6931471805599453 - * ( - ( - 0.6931471805599453 - - 0.6931471805599453 * np.power(2.0, -2.0 - 1.0 * n) - ) - / (2.0 + n) - + mp.hyper(list([1.0, 1.0, -1.0 - 1.0 * n]), list([2.0, 2.0]), 0.5) - ) - + mp.hyper( - list([1.0, 1.0, 1.0, -1.0 - 1.0 * n]), list([2.0, 2.0, 2.0]), 0.5 - ) - ) - - 3.3333333333333335 - * ( - 0.6931471805599453 - * ( - (0.6931471805599453 - 0.6931471805599453 / np.power(2.0, 1.0 * n)) - / n - + mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), 0.5) - ) - + mp.hyper( - list([1.0, 1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0, 2.0]), 0.5 - ) - ) - + 7.0 - * ( - 0.6931471805599453 - * ( - ( - 0.6931471805599453 - - 0.6931471805599453 * np.power(2.0, -1.0 - 1.0 * n) - ) - / (1.0 + n) - + mp.hyper(list([1.0, 1.0, -1.0 * n]), list([2.0, 2.0]), 0.5) - ) - + mp.hyper(list([1.0, 1.0, 1.0, -1.0 * n]), list([2.0, 2.0, 2.0]), 0.5) - ) - ) - ) - - -# @nb.njit("c16()", cache=True) -def H25(n, S1, S2): - return complex( - -0.9765080063055425 - + 0.3465324280753968 / np.power(1.0 + n, 2) - + 0.5313147349319273 / (1.0 + n) - + 0.09653242807539683 / np.power(2.0 + n, 2) - + 0.10802793979194095 / (2.0 + n) - + 0.034032428075396824 / np.power(3.0 + n, 2) - + 0.03345624100694436 / (3.0 + n) - + 0.013199094742063492 / np.power(4.0 + n, 2) - + 0.012071230300834391 / (4.0 + n) - + 0.005386594742063492 / np.power(5.0 + n, 2) - + 0.00470289295270982 / (5.0 + n) - + 0.0022615947420634923 / np.power(6.0 + n, 2) - + 0.001911808013459991 / (6.0 + n) - + 0.0009595114087301587 / np.power(7.0 + n, 2) - + 0.0007922587332170066 / (7.0 + n) - + 0.00040147569444444443 / np.power(8.0 + n, 2) - + 0.00032573846345300655 / (8.0 + n) - - complex(28823.33170068027, 67307.76191106241) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + (1801.458231292517 * np.power(2.0, 4.0 + n)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (complex(60934.848533133685, 182932.88147970886) * n) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + (45750.521632653064 * np.power(2.0, n) * n) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (complex(55310.196621119074, 197189.03938448254) * np.power(n, 2)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + (3.15990922e7 * np.power(2.0, -10.0 + n) * np.power(n, 2)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (complex(27899.370995930713, 112319.8276890854) * np.power(n, 3)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + (9.26168518740136e7 * np.power(2.0, -13.0 + n) * np.power(n, 3)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (complex(8521.952753241852, 37474.99868902381) * np.power(n, 4)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + (3.967415195020408e7 * np.power(2.0, -14.0 + n) * np.power(n, 4)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (complex(1612.5907721691867, 7572.123214994521) * np.power(n, 5)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + (4.965773963265306e6 * np.power(2.0, -14.0 + n) * np.power(n, 5)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (complex(184.6934149990644, 911.45927587897) * np.power(n, 6)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + (336550.07972789113 * np.power(2.0, -14.0 + n) * np.power(n, 6)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (complex(11.719635588798857, 60.09621599202) * np.power(n, 7)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + (9538.758911564626 * np.power(2.0, -14.0 + n) * np.power(n, 7)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (complex(0.315923902660914, 1.6693393331116668) * np.power(n, 8)) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + 0.00015733506944444445 / np.power(9.0 + n, 2) - + 0.0001259954994491137 / (9.0 + n) - + 0.000048828125 / np.power(10.0 + n, 2) - + 0.000038727889675778575 / (10.0 + n) - + 0.5313147349319273 * S1 - - (21424.726033195955 * S1) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (58229.344683079005 * n * S1) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (62767.220683165644 * np.power(n, 2) * S1) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (35752.51156789575 * np.power(n, 3) * S1) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (11928.662567440875 * np.power(n, 4) * S1) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (2410.2816787345455 * np.power(n, 5) * S1) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (290.1264983661953 * np.power(n, 6) * S1) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (19.12921967249639 * np.power(n, 7) * S1) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - (0.5313672131248997 * np.power(n, 8) * S1) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + 0.3465324280753968 * S2 - + ( - 3.004709057142857e6 - * np.power(2.0, -7.0 + n) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - ( - 1036.3084621143826 - * np.power(2.0, 6.0 + n) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + ( - 4.1293287328163266e7 - * np.power(2.0, -10.0 + n) - * n - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - ( - 14241.839150771944 - * np.power(2.0, 3.0 + n) - * n - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + ( - 1.165159401047619e8 - * np.power(2.0, -12.0 + n) - * np.power(n, 2) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - ( - 40185.73925310217 - * np.power(2.0, 1.0 + n) - * np.power(n, 2) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + ( - 2.1967761773333333e7 - * np.power(2.0, -11.0 + n) - * np.power(n, 3) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - ( - 7576.5663119029305 - * np.power(2.0, 2.0 + n) - * np.power(n, 3) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + ( - 3.839350461904762e7 - * np.power(2.0, -14.0 + n) - * np.power(n, 4) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - ( - 13241.719238128222 - * np.power(2.0, -1.0 + n) - * np.power(n, 4) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + ( - 4.874305803809524e6 - * np.power(2.0, -14.0 + n) - * np.power(n, 5) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - ( - 1681.1226163188874 - * np.power(2.0, -1.0 + n) - * np.power(n, 5) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + ( - 333856.5619047619 - * np.power(2.0, -14.0 + n) - * np.power(n, 6) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - ( - 115.14538467937584 - * np.power(2.0, -1.0 + n) - * np.power(n, 6) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - + ( - 9538.758911564626 - * np.power(2.0, -14.0 + n) - * np.power(n, 7) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - ( - 3.2898681336964524 - * np.power(2.0, -1.0 + n) - * np.power(n, 7) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - ) - - -# @nb.njit("c16(c16,c16,c16)", cache=True) -def H26(n, S1, S2): - """Linear combination of S211l2051 + S211l2105 - S22l205""" - return complex( - 0.08333333333333333 - * ( - complex(-16.23484850566707, 21.491913260611398) - + ( - -2.842170943040401e-14 - + 173.50286458333323 * n - + 243.46289062500009 * np.power(n, 2) - + 119.69466145833336 * np.power(n, 3) - + 24.755859375 * np.power(n, 4) - + 1.8337239583333333 * np.power(n, 5) - ) - / ( - 120.0 - + 274.0 * n - + 225.0 * np.power(n, 2) - + 85.0 * np.power(n, 3) - + 15.0 * np.power(n, 4) - + np.power(n, 5) - ) - + ( - 8.731149137020111e-11 - - 787729.060111111 * n - - 3.0080453892458337e6 * np.power(n, 2) - - 5.05889901240764e6 * np.power(n, 3) - - 4.936113066185765e6 * np.power(n, 4) - - 3.095514310441841e6 * np.power(n, 5) - - 1.3041688939354168e6 * np.power(n, 6) - - 373993.2982185764 * np.power(n, 7) - - 72116.17108854167 * np.power(n, 8) - - 8953.494551215279 * np.power(n, 9) - - 646.6595444444445 * np.power(n, 10) - - 20.644269618055556 * np.power(n, 11) - ) - / ( - np.power(1.0 + n, 2) - * np.power(2.0 + n, 3) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - ) - + ( - np.power(n, 3) * (1.283807919976604e10 - 1.608646369206041e10 * S1) - + np.power(n, 2) * (9.294220799968464e9 - 1.5655859137235104e10 * S1) - + np.power(n, 4) * (1.0596601907417942e10 - 1.0982580115748644e10 * S1) - + n * (3.028465456549388e9 - 9.00503846537143e9 * S1) - + np.power(n, 5) * (5.843292892011012e9 - 5.294110506123972e9 * S1) - + np.power(n, 6) * (2.2769289339052258e9 - 1.8644748220271614e9 * S1) - + np.power(n, 7) * (6.458907520321677e8 - 4.886203781899511e8 * S1) - + np.power(n, 8) * (1.3519818853965065e8 - 9.595384412927225e7 * S1) - + np.power(n, 9) * (2.090277859286008e7 - 1.4075312614993623e7 * S1) - + np.power(n, 10) * (2.3595465377532723e6 - 1.5203445475602325e6 * S1) - + np.power(n, 11) * (189161.71919246286 - 117403.416519983 * S1) - + np.power(n, 12) * (10205.69539860453 - 6133.497436933107 * S1) - + np.power(n, 13) * (332.32934015883137 - 194.2227274659864 * S1) - + np.power(n, 14) * (4.93556152059038 - 2.8148221371882087 * S1) - - 2.288031552e9 * S1 - ) - / ( - (1.0 + n) - * (2.0 + n) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - ) - + 18.614449574968226 * S1 - + 1.6449340668482262 * (9.869604401089358 - 6.0 * S2) - + 16.848146067756026 * S2 - + 6.841088463857115 * mp.betainc(1.0 + n, 0.0, x2=2.0) - + ( - complex(2.923121728206675e19, 3.701550063528897e19) - - 2.9231217212083933e19 * np.power(2.0, n) - + 1.1782399794254862e19 * S1 - + np.power(n, 21) - * ( - complex(6.758658057013846, 15.214546459695082) - + 4.8429405519235385 * S1 - ) - + np.power(n, 20) - * ( - complex(1431.8422861969393, 3210.269302995662) - - 17.26786632043568 * np.power(2.0, n) - + 1021.8604564558666 * S1 - ) - + np.power(n, 19) - * ( - complex(141958.51946738732, 316842.9300231501) - - 3589.81189979833 * np.power(2.0, n) - + 100854.23699380769 * S1 - ) - + np.power(n, 18) - * ( - complex(8.752539210101698e6, 1.943605059313438e7) - - 348830.0180568167 * np.power(2.0, n) - + 6.186687052163003e6 * S1 - ) - + np.power(n, 17) - * ( - complex(3.761407002787435e8, 8.304829147349784e8) - - 2.1047447076496072e7 * np.power(2.0, n) - + 2.6435092206687373e8 * S1 - ) - + np.power(n, 16) - * ( - complex(1.1968726692676088e10, 2.6254354741564106e10) - - 8.83520877339768e8 * np.power(2.0, n) - + 8.357020669616135e9 * S1 - ) - + np.power(n, 15) - * ( - complex(2.923873280138507e11, 6.36638280062443e11) - - 2.7398953857335464e10 * np.power(2.0, n) - + 2.0264825846692044e11 * S1 - ) - + np.power(n, 14) - * ( - complex(5.611456769193843e12, 1.2115084031103225e13) - - 6.505518151452606e11 * np.power(2.0, n) - + 3.8563510190475283e12 * S1 - ) - + np.power(n, 13) - * ( - complex(8.586610348984605e13, 1.8358462356351503e14) - - 1.2095125413375354e13 * np.power(2.0, n) - + 5.843680063159655e13 * S1 - ) - + np.power(n, 12) - * ( - complex(1.0571874861459436e15, 2.2349477992893992e15) - - 1.785829223423589e14 * np.power(2.0, n) - + 7.114059796185222e14 * S1 - ) - + np.power(n, 11) - * ( - complex(1.0523151695692176e16, 2.1956419230015896e16) - - 2.1112713439294792e15 * np.power(2.0, n) - + 6.988945306109954e15 * S1 - ) - + np.power(n, 10) - * ( - complex(8.47844216720592e16, 1.7420404467752794e17) - - 2.005909067824641e16 * np.power(2.0, n) - + 5.5450869634059896e16 * S1 - ) - + np.power(n, 9) - * ( - complex(5.5174139967361075e17, 1.1132957115890166e18) - - 1.531123605403968e17 * np.power(2.0, n) - + 3.543730312448022e17 * S1 - ) - + np.power(n, 8) - * ( - complex(2.884166025765176e18, 5.695785397422142e18) - - 9.350839180163167e17 * np.power(2.0, n) - + 1.813024801580739e18 * S1 - ) - + np.power(n, 7) - * ( - complex(1.1999636924131482e19, 2.3095399249450648e19) - - 4.5317048835340575e18 * np.power(2.0, n) - + 7.351493906461836e18 * S1 - ) - + np.power(n, 6) - * ( - complex(3.919356154375745e19, 7.313065470087013e19) - - 1.720130723544719e19 * np.power(2.0, n) - + 2.327821037438006e19 * S1 - ) - + n - * ( - complex(1.2214732964559317e20, 1.701876351998952e20) - - 1.0858123503594557e20 * np.power(2.0, n) - + 5.417240679036713e19 * S1 - ) - + np.power(n, 5) - * ( - complex(9.853818099925572e19, 1.7706371703968426e20) - - 5.015528326226779e19 * np.power(2.0, n) - + 5.636113161818078e19 * S1 - ) - + np.power(n, 4) - * ( - complex(1.8537407017470958e20, 3.181170428188106e20) - - 1.0918493529864626e20 * np.power(2.0, n) - + 1.012597996927796e20 * S1 - ) - + np.power(n, 2) - * ( - complex(2.266977589532697e20, 3.4319007865484195e20) - - 1.7687906077677814e20 * np.power(2.0, n) - + 1.0924079487602891e20 * S1 - ) - + np.power(n, 3) - * ( - complex(2.502191229329443e20, 4.0584332549912664e20) - - 1.7002838382983096e20 * np.power(2.0, n) - + 1.2918394274807806e20 * S1 - ) - + np.power(2.0, n) - * ( - 2.3564799588509725e19 - + 8.478001399222454e19 * n - + 1.3370157575983325e20 * np.power(n, 2) - + 1.2466630973632286e20 * np.power(n, 3) - + 7.785328964923633e19 * np.power(n, 4) - + 3.486897358712523e19 * np.power(n, 5) - + 1.1687447161634896e19 * np.power(n, 6) - + 3.0155406512887823e18 * np.power(n, 7) - + 6.105089518726959e17 * np.power(n, 8) - + 9.82371106169081e16 * np.power(n, 9) - + 1.2664628651211698e16 * np.power(n, 10) - + 1.3132619610082072e15 * np.power(n, 11) - + 1.0954999822883712e14 * np.power(n, 12) - + 7.32360303435598e12 * np.power(n, 13) - + 3.89099003739077e11 * np.power(n, 14) - + 1.6197513194763893e10 * np.power(n, 15) - + 5.165281444683772e8 * np.power(n, 16) - + 1.2173699665370196e7 * np.power(n, 17) - + 199674.43895580748 * np.power(n, 18) - + 2034.0350318078856 * np.power(n, 19) - + 9.685881103847077 * np.power(n, 20) - ) - * mp.hyp2f1(1.0, 1.0 + n, 2.0 + n, 2.0) - ) - / ( - np.power(1.0 + n, 2) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - * (16.0 + n) - * (17.0 + n) - * (18.0 + n) - * (19.0 + n) - * (20.0 + n) - ) - + 20.523265391571346 - * n - * mp.hyper(list([1.0, 1.0, 1.0 - 1.0 * n]), list([2.0, 2.0]), -1.0) - ) - ) - - -# @nb.njit("c16(c16,c16,c16)", cache=True) -def H27(n, S1, S2, S3, H21, H23, H24, H25): - """Linear combination of + S1111l21105 + S112l2051 - S112l2105 + S121l2105 - S13l205""" - return complex( - 0.125 - * ( - complex(0.0, -3.7763731361630786) - + 6.579736267392905 * H21 - - 4.657924211720099 * H23 - + 5.545177444479562 * H24 - + 11.090354888959125 * H25 - + ( - np.power(n, 2) * (166512.82004488667 - 201720.28849894297 * S1) - + n * (90242.14129258736 - 187136.5352923044 * S1) - + np.power(n, 3) * (123906.8708531517 - 114900.84903459821 * S1) - + np.power(n, 4) * (48677.646427379485 - 38336.14469974578 * S1) - + np.power(n, 5) * (10981.454596417643 - 7746.124654017857 * S1) - + np.power(n, 6) * (1430.3006794295188 - 932.4038935391865 * S1) - + np.power(n, 7) * (100.01173626580466 - 61.477179793792516 * S1) - + np.power(n, 8) * (2.906155595873952 - 1.7076994387164588 * S1) - - 68854.44136904762 * S1 - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - ) - - 1.2020569031595942 * S1 - + ( - -0.0007336773090573695 - + 7.859495005696298e12 * S1 - + np.power(n, 16) * (-9.241075421102035 + 6.010284515797971 * S1) - + np.power(n, 15) * (-1105.0106534185607 + 727.2444264115545 * S1) - + np.power(n, 14) * (-60346.64835347673 + 40268.9062558464 * S1) - + np.power(n, 13) * (-1.993703454858508e6 + 1.3521938103642275e6 * S1) - + np.power(n, 12) * (-4.44876775337904e7 + 3.0760768378113363e7 * S1) - + np.power(n, 11) * (-7.08869171754117e8 + 5.016069381684878e8 * S1) - + np.power(n, 10) * (-8.31402318508655e9 + 6.050278271228684e9 * S1) - + np.power(n, 9) * (-7.290123023992578e10 + 5.490829893512993e10 * S1) - + np.power(n, 8) * (-4.803845044281605e11 + 3.776788115127787e11 * S1) - + np.power(n, 7) * (-2.3703519754219824e12 + 1.9679735450429246e12 * S1) - + np.power(n, 6) * (-8.648840275214252e12 + 7.708041544226011e12 * S1) - + np.power(n, 5) * (-2.279484275757239e13 + 2.2337134969431023e13 * S1) - + n * (-1.001207262580593e13 + 3.3939099205736223e13 * S1) - + np.power(n, 4) * (-4.172983402985361e13 + 4.6662701313365234e13 * S1) - + np.power(n, 2) * (-3.406665456546434e13 + 6.313792233702593e13 * S1) - + np.power(n, 3) * (-4.9683192493158414e13 + 6.745230111213624e13 * S1) - ) - / ( - np.power(1.0 + n, 2) - * (2.0 + n) - * (3.0 + n) - * (4.0 + n) - * (5.0 + n) - * (6.0 + n) - * (7.0 + n) - * (8.0 + n) - * (9.0 + n) - * (10.0 + n) - * (11.0 + n) - * (12.0 + n) - * (13.0 + n) - * (14.0 + n) - * (15.0 + n) - ) - + ( - -99.32989848572531 - + np.power(n, 22) * (-0.9355100821131798 + 0.4434370468112737 * S1) - + 2.20443858177543e17 * S1 - + np.power(n, 21) * (-150.57465290980792 + 72.28023863023762 * S1) - + np.power(n, 20) * (-11440.89362181615 + 5568.238996809164 * S1) - + np.power(n, 19) * (-545637.9723982998 + 269603.0729055522 * S1) - + np.power(n, 18) * (-1.831915210236284e7 + 9.203188251923285e6 * S1) - + np.power(n, 17) * (-4.6026794036908334e8 + 2.355049625666434e8 * S1) - + np.power(n, 16) * (-8.980394422508726e9 + 4.689184455219479e9 * S1) - + np.power(n, 15) * (-1.3935836364261557e11 + 7.442871888563174e10 * S1) - + np.power(n, 14) * (-1.7473045567526182e12 + 9.570690955792218e11 * S1) - + np.power(n, 13) * (-1.788249770162659e13 + 1.0077248092011773e13 * S1) - + np.power(n, 12) * (-1.5028583043797556e14 + 8.745996801754348e13 * S1) - + np.power(n, 11) * (-1.0397819620196205e15 + 6.277592605543988e14 * S1) - + np.power(n, 10) * (-5.918876268424598e15 + 3.728069626046019e15 * S1) - + np.power(n, 9) * (-2.7616961613784108e16 + 1.827505362846522e16 * S1) - + np.power(n, 8) * (-1.0485747029269587e17 + 7.35547191411904e16 * S1) - + np.power(n, 7) * (-3.2026270760658944e17 + 2.4096459143424966e17 * S1) - + np.power(n, 6) * (-7.734424871788384e17 + 6.34230567720652e17 * S1) - + n * (-3.1340087860049805e17 + 9.809776158193391e17 * S1) - + np.power(n, 5) * (-1.4397938063193528e18 + 1.3162578486499904e18 * S1) - + np.power(n, 2) * (-1.1354522813905171e18 + 1.9870632431050053e18 * S1) - + np.power(n, 4) * (-1.9873066473809416e18 + 2.0959888940331604e18 * S1) - + np.power(n, 3) * (-1.9092369511909688e18 + 2.4579847528339195e18 * S1) - ) - / ( - (1.0 + n) - * (2.0 + n) - * (3.0 + n) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - * np.power(10.0 + n, 2) - * np.power(11.0 + n, 2) - * np.power(12.0 + n, 2) - * (13.0 + n) - ) - + ( - 0.0771690749603064 - - 2.9265897542022e14 * S1 - + np.power(n, 4) - * ( - 1.8646570771238136e16 - - 1.3567688107232536e16 * S1 - - 1.0548153213696288e16 * S2 - ) - + np.power(n, 5) - * ( - 2.006984550292455e16 - - 1.2773238283187784e16 * S1 - - 9.930510885955058e15 * S2 - ) - + np.power(n, 3) - * ( - 1.2060026786369336e16 - - 1.0617379594680504e16 * S1 - - 8.254445842763882e15 * S2 - ) - + np.power(n, 6) - * ( - 1.5999759249027844e16 - - 9.21604560332962e15 * S1 - - 7.164983472498301e15 * S2 - ) - + np.power(n, 2) - * ( - 4.837597500758669e15 - - 5.743240540248003e15 * S1 - - 4.4650629261851955e15 * S2 - ) - + np.power(n, 7) - * ( - 9.812573238712292e15 - - 5.231530703029538e15 * S1 - - 4.067235844572178e15 * S2 - ) - + np.power(n, 8) - * ( - 4.746103710138956e15 - - 2.3789804686183455e15 * S1 - - 1.8495303162224455e15 * S2 - ) - + n - * ( - 9.045778042903921e14 - - 1.9094836801028798e15 * S1 - - 1.48452162649884e15 * S2 - ) - + np.power(n, 9) - * ( - 1.840940524250164e15 - - 8.775056435445015e14 * S1 - - 6.822137935980728e14 * S2 - ) - + np.power(n, 10) - * ( - 5.790852192475322e14 - - 2.6475047063537547e14 * S1 - - 2.0582935763178938e14 * S2 - ) - + np.power(n, 11) - * ( - 1.4876049616692416e14 - - 6.566727023740917e13 * S1 - - 5.105279706571004e13 * S2 - ) - + np.power(n, 12) - * ( - 3.1320532612514152e13 - - 1.3419476939923623e13 * S1 - - 1.0432926943133523e13 * S2 - ) - + np.power(n, 13) - * ( - 5.407223538821024e12 - - 2.258177069167195e12 * S1 - - 1.7556121220485374e12 * S2 - ) - + np.power(n, 14) - * ( - 7.63456855164813e11 - - 3.118465040960098e11 * S1 - - 2.4244400949980518e11 * S2 - ) - + np.power(n, 15) - * ( - 8.762636459456693e10 - - 3.510751241827666e10 * S1 - - 2.729421674591126e10 * S2 - ) - + np.power(n, 16) - * ( - 8.092703316488976e9 - - 3.1878704982672825e9 * S1 - - 2.4783991329532785e9 * S2 - ) - + np.power(n, 17) - * ( - 5.919991763679658e8 - - 2.2974237677951336e8 * S1 - - 1.7861243351085195e8 * S2 - ) - + np.power(n, 18) - * ( - 3.3493266574617792e7 - - 1.2827181926884457e7 * S1 - - 9.9724491892327e6 * S2 - ) - + np.power(n, 19) - * ( - 1.4123719882349833e6 - - 534577.9631170281 * S1 - - 415605.82872023806 * S2 - ) - + np.power(n, 20) - * ( - 41761.32565753581 - - 15641.245465554583 * S1 - - 12160.233366195433 * S2 - ) - + np.power(n, 21) - * (772.0492467310804 - 286.4516062526573 * S1 - 222.70083209325392 * S2) - + np.power(n, 22) - * (6.712196914492478 - 2.4694103987298046 * S1 - 1.919834759424603 * S2) - - 2.2752673025039997e14 * S2 - ) - / ( - np.power(1.0 + n, 2) - * np.power(2.0 + n, 2) - * np.power(3.0 + n, 4) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - * np.power(7.0 + n, 2) - * np.power(8.0 + n, 2) - * np.power(9.0 + n, 2) - * np.power(10.0 + n, 2) - ) - + ( - -1.5027717445776854e-9 - - 6.69187577857838e6 * S1 - + np.power(n, 4) - * ( - 2.7802697767986834e8 - - 1.7598306282171097e8 * S1 - - 2.0899366776840028e8 * S2 - ) - + np.power(n, 3) - * ( - 2.2290863736359698e8 - - 1.6617600527154762e8 * S1 - - 1.9734701896844792e8 * S2 - ) - + np.power(n, 5) - * ( - 2.3233586127079147e8 - - 1.3185401467528436e8 * S1 - - 1.5658696749069476e8 * S2 - ) - + np.power(n, 2) - * ( - 1.0735720397100002e8 - - 1.0481893979951563e8 * S1 - - 1.2448069904596138e8 * S2 - ) - + np.power(n, 6) - * ( - 1.3733480754676133e8 - - 7.21556540222501e7 * S1 - - 8.569048942860737e7 * S2 - ) - + n - * ( - 2.346811804325443e7 - - 3.948206709361244e7 * S1 - - 4.688804638734895e7 * S2 - ) - + np.power(n, 7) - * ( - 5.9068956110853195e7 - - 2.9326900334110886e7 * S1 - - 3.4827990641994946e7 * S2 - ) - + np.power(n, 8) - * ( - 1.8716920175328404e7 - - 8.904006082429819e6 * S1 - - 1.0574204466962924e7 * S2 - ) - + np.power(n, 9) - * ( - 4.369502175593268e6 - - 2.0112998054058799e6 * S1 - - 2.3885760173381087e6 * S2 - ) - + np.power(n, 10) - * (742367.1089287619 - 333002.79029907763 * S1 - 395466.8898575944 * S2) - + np.power(n, 11) - * (89238.96159823332 - 39216.66399560401 * S1 - 46572.85942560097 * S2) - + np.power(n, 12) - * (7189.465207901569 - 3107.7721714752024 * S1 - 3690.722813269728 * S2) - + np.power(n, 13) - * ( - 348.04953328095235 - - 148.45017641522256 * S1 - - 176.29620914891743 * S2 - ) - + np.power(n, 14) - * (7.649609990582573 - 3.227177748157012 * S1 - 3.832526285846031 * S2) - - 7.94712650633033e6 * S2 - ) - / ( - np.power(1.0 + n, 2) - * np.power(2.0 + n, 4) - * np.power(3.0 + n, 2) - * np.power(4.0 + n, 2) - * np.power(5.0 + n, 2) - * np.power(6.0 + n, 2) - ) - + ( - -2.0536305397787174e17 * S1 - - 2.2256200168054272e17 * S2 - + np.power(n, 7) - * ( - 7.488098037238662e20 - - 2.946375088218397e20 * S1 - - 3.193131016673674e20 * S2 - - 3.799456323070507e20 * S3 - ) - + np.power(n, 8) - * ( - 7.30264831364528e20 - - 2.71532571821718e20 * S1 - - 2.9427314960274712e20 * S2 - - 3.5015098758232205e20 * S3 - ) - + np.power(n, 6) - * ( - 6.177204922810032e20 - - 2.6157067495896564e20 * S1 - - 2.8347695397084837e20 * S2 - - 3.373047643786608e20 * S3 - ) - + np.power(n, 9) - * ( - 5.8400874656639694e20 - - 2.0769852191609772e20 * S1 - - 2.2509306269236576e20 * S2 - - 2.6783469136093286e20 * S3 - ) - + np.power(n, 5) - * ( - 3.991243537765913e20 - - 1.863520884696265e20 * S1 - - 2.019588870723487e20 * S2 - - 2.4030770002248768e20 * S3 - ) - + np.power(n, 10) - * ( - 3.884280841236816e20 - - 1.3331261847836026e20 * S1 - - 1.4447741520738879e20 * S2 - - 1.719114016569323e20 * S3 - ) - + np.power(n, 4) - * ( - 1.941539256202762e20 - - 1.037136201699684e20 * S1 - - 1.1239953077952802e20 * S2 - - 1.3374243202062749e20 * S3 - ) - + np.power(n, 11) - * ( - 2.1714818176898564e20 - - 7.240795785261171e19 * S1 - - 7.84720509610949e19 * S2 - - 9.337265794969823e19 * S3 - ) - + np.power(n, 3) - * ( - 6.674068902186431e19 - - 4.334180202679847e19 * S1 - - 4.697163403386798e19 * S2 - - 5.589080780056582e19 * S3 - ) - + np.power(n, 12) - * ( - 1.0285760474577702e20 - - 3.3495073506999865e19 * S1 - - 3.630025197696012e19 * S2 - - 4.319309830468156e19 * S3 - ) - + np.power(n, 13) - * ( - 4.152987402406034e19 - - 1.3260813853758188e19 * S1 - - 1.437139357853292e19 * S2 - - 1.7100294951308622e19 * S3 - ) - + np.power(n, 2) - * ( - 1.4426634312692584e19 - - 1.2766361168145222e19 * S1 - - 1.383553098146518e19 * S2 - - 1.646268048384875e19 * S3 - ) - + np.power(n, 14) - * ( - 1.4355806022040816e19 - - 4.5090539738436506e18 * S1 - - 4.886682675708466e18 * S2 - - 5.814586778340482e18 * S3 - ) - + n - * ( - 1.4722170431513467e18 - - 2.3589858426577193e18 * S1 - - 2.556548516923281e18 * S2 - - 3.0419968291746964e18 * S3 - ) - + np.power(n, 15) - * ( - 4.2611489273254656e18 - - 1.3198929523220705e18 * S1 - - 1.4304326498012352e18 * S2 - - 1.7020492888122632e18 * S3 - ) - + np.power(n, 16) - * ( - 1.0879213298582682e18 - - 3.330098647641433e17 * S1 - - 3.608991035420647e17 * S2 - - 4.294281611945237e17 * S3 - ) - + np.power(n, 17) - * ( - 2.3903221211390477e17 - - 7.242566351952211e16 * S1 - - 7.849123945967018e16 * S2 - - 9.339549004204315e16 * S3 - ) - + np.power(n, 18) - * ( - 4.516433468485152e16 - - 1.3564628989469896e16 * S1 - - 1.4700652924043664e16 * S2 - - 1.7492075462568086e16 * S3 - ) - + np.power(n, 19) - * ( - 7.324075821658249e15 - - 2.1829261559919405e15 * S1 - - 2.3657440098778855e15 * S2 - - 2.814961550328176e15 * S3 - ) - + np.power(n, 20) - * ( - 1.0158957617673035e15 - - 3.007636290956304e14 * S1 - - 3.25952278307278e14 * S2 - - 3.878454840615735e14 * S3 - ) - + np.power(n, 21) - * ( - 1.1991809347780238e14 - - 3.529401882158612e13 * S1 - - 3.8249857139003e13 * S2 - - 4.551290279179315e13 * S3 - ) - + np.power(n, 22) - * ( - 1.1961219447874947e13 - - 3.5021031665673315e12 * S1 - - 3.795400758536529e12 * S2 - - 4.516087606586902e12 * S3 - ) - + np.power(n, 23) - * ( - 9.983887045155367e11 - - 2.909667375174094e11 * S1 - - 3.153349069853116e11 * S2 - - 3.752120410888339e11 * S3 - ) - + np.power(n, 24) - * ( - 6.881721914457945e10 - - 1.9973221161205063e10 * S1 - - 2.164595819715926e10 * S2 - - 2.575618485795491e10 * S3 - ) - + np.power(n, 25) - * ( - 3.8459999519303937e9 - - 1.1121280148924243e9 * S1 - - 1.2052676093633516e9 * S2 - - 1.4341289522651784e9 * S3 - ) - + np.power(n, 26) - * ( - 1.6979480143673667e8 - - 4.893579744396906e7 * S1 - - 5.303412089955037e7 * S2 - - 6.310446547232142e7 * S3 - ) - + np.power(n, 27) - * ( - 5.6960113322322285e6 - - 1.6367080201903752e6 * S1 - - 1.7737806586155398e6 * S2 - - 2.110593678720238e6 * S3 - ) - + np.power(n, 28) - * ( - 136369.8397219097 - - 39078.72687348644 * S1 - - 42351.53065569196 * S2 - - 50393.41953125001 * S3 - ) - + np.power(n, 29) - * ( - 2074.721945948902 - - 593.0786658463794 * S1 - - 642.7484032206632 * S2 - - 764.7962053571429 * S3 - ) - + np.power(n, 30) - * ( - 15.06796770343253 - - 4.297671491640431 * S1 - - 4.657597124787415 * S2 - - 5.542001488095237 * S3 - ) - - 2.648230217127936e17 * S3 - ) - / ( - np.power(1.0 + n, 6) - * np.power(2.0 + n, 3) - * np.power(3.0 + n, 3) - * np.power(4.0 + n, 3) - * np.power(5.0 + n, 3) - * np.power(6.0 + n, 3) - * np.power(7.0 + n, 3) - * np.power(8.0 + n, 3) - * np.power(9.0 + n, 3) - ) - - 1.2020569031595942 * mp.betainc(1.0 + n, 0.0, x2=2.0) - ) - ) diff --git a/tests/test_cs_functions.py b/tests/test_cs_functions.py deleted file mode 100644 index 8dec308ca..000000000 --- a/tests/test_cs_functions.py +++ /dev/null @@ -1,255 +0,0 @@ -# -*- coding: utf-8 -*- -# Test cs functions -import numpy as np - -from eko.anomalous_dimensions import harmonics -import eko.matching_conditions.n3lo.cs_functions as csf -import eko.matching_conditions.n3lo.h_functions as hf - - -# reference values coming fom mathematica -testNinteger = [1, 2, 10, 100] -refvalsinteger = { - "S1l05": [0.5, 0.625, 0.693065, 0.693147], - "S111l211": [2.0, 5.5, 1092.6, 3.64201e29], - "S12l21": [2.0, 4.5, 361.913, 4.18766e28], - "S21l21": [2.0, 3.5, 80.0103, 1.33999e27], - "S3l2": [2.0, 2.5, 6.1981, 2.61629e24], - "S1111l20511": [1.0, 2.4375, 211.939, 2.30926e28], - "S1111l21051": [1.0, 2.6875, 438.767, 9.83117e28], - "S121l2051": [1.0, 2.3125, 177.276, 1.92438e28], - "S13l205": [1.0, 2.0625, 127.392, 1.37604e28], - "S211l2051": [1.0, 1.6875, 24.6954, 2.1289e26], - "S22l205": [1.0, 1.5625, 17.9259, 1.50709e26], -} - - -testN = [1.2, 2 + 2j, 10 - 10j, 100 + 5j] -refvals = { - "S1l05": [ - 0.538137, - 0.712215 + 0.0553881j, - 0.693133 - 0.0000611141j, - 0.693147 - 2.81649e-33j, - ], - "S111l211": [ - 2.54956, - 0.757758 + 7.14874j, - 909.774 - 228.694j, - -3.48531e29 - 1.04752e29j, - ], - "S12l21": [ - 2.44162, - 2.49213 + 5.02065j, - 237.335 + 37.1463j, - -4.02641e28 - 1.13156e28j, - ], - "S21l21": [ - 2.30848, - 3.16611 + 2.64925j, - 27.0649 + 23.3928j, - -1.30088e27 - 3.08519e26j, - ], - "S3l2": [ - 2.13581, - 2.68836 + 0.514803j, - 2.47645 + 0.00409976j, - -2.56754e24 - 4.47673e23j, - ], - "S1111l20511": [ - 1.24503, - 1.1248 + 3.00684j, - 131.725 + 24.7849j, - -2.22049e28 - 6.23296e27j, - ], - "S1111l21051": [ - 1.26935, - 0.553945 + 3.4886j, - 348.464 - 34.3895j, - -9.42727e28 - 2.75605e28j, - ], - "S1111l21105": [ - 1.28092, - 0.240202 + 3.69116j, - 518.932 - 150.299j, - -2.12395e29 - 6.4095e28j, - ], - "S112l2051": [ - 1.23026 - 7.87292e-16j, - 1.26939 + 2.68422j, - 110.53 + 20.4704j, - -1.85041e28 - 5.19414e27j, - ], - "S112l2105": [ - 1.25606 + 1.90605e-16j, - 0.778372 + 3.21344j, - 276.555 - 18.8422j, - -7.17239e28 - 2.09103e28j, - ], - "S121l2051": [ - 1.23026 - 7.87292e-16j, - 1.26939 + 2.68422j, - 110.53 + 20.4704j, - -1.85041e28 - 5.19414e27j, - ], - "S121l2105": [ - 1.22865 - 5.91011e-18j, - 1.18968 + 2.66297j, - 132.763 + 19.9346j, - -2.26363e28 - 6.36336e27j, - ], - "S13l205": [ - 1.19667, - 1.39248 + 2.05457j, - 79.7069 + 14.5882j, - -1.32315e28 - 3.71411e27j, - ], - "S211l2051": [ - 1.14671, - 1.64933 + 1.16434j, - 5.5855 + 6.21788j, - -2.07082e26 - 4.69937e25j, - ], - "S211l2105": [ - 1.1634, - 1.57541 + 1.47654j, - 16.9764 + 14.4009j, - -8.41216e26 - 2.00123e26j, - ], - "S22l205": [ - 1.12596, - 1.5831 + 0.877058j, - 4.40596 + 4.39592j, - -1.46597e26 - 3.32677e25j, - ], - "S31l205": [ - 1.08185, - 1.42797 + 0.349638j, - 1.28279 + 0.00292271j, - -1.77969e24 - 3.10303e23j, - ], -} - -# compare the exact values of some harmonics -def test_S1l05(): - for N, vals in zip(testN, refvals["S1l05"]): - test = csf.S1l05(N) - np.testing.assert_allclose(test, vals, rtol=1e-05) - for N, vals in zip(testNinteger, refvalsinteger["S1l05"]): - test = csf.S1l05(N) - np.testing.assert_allclose(test, vals, rtol=1e-05) - - -def test_S111l211(): - for N, vals in zip(testN, refvals["S111l211"]): - S1 = harmonics.harmonic_S1(N) - H22 = hf.H22(N, S1) - H24 = hf.H24(N, S1) - test = csf.S111l211(H22, H24) - np.testing.assert_allclose(test, vals, rtol=2e-05) - - -def test_S12l21(): - for N, vals in zip(testN, refvals["S12l21"]): - S1 = harmonics.harmonic_S1(N) - S2 = harmonics.harmonic_S2(N) - H25 = hf.H25(N, S1, S2) - test = csf.S12l21(H25) - np.testing.assert_allclose(test, vals, rtol=1e-05) - - -def test_S21l21(): - for N, vals in zip(testN, refvals["S21l21"]): - S1 = harmonics.harmonic_S1(N) - test = csf.S21l21(N, S1) - rtol = 15e-03 - if N == 100 + 5j: - rtol = 25e-02 - np.testing.assert_allclose(test, vals, rtol=rtol) - - -def test_S3l2(): - for N, vals in zip(testN, refvals["S3l2"]): - test = csf.S3l2(N) - # TODO: here Mathematica and mpmath do not agree on LerchPhi, - # when the 3rd argument is complex and first real... - np.testing.assert_allclose(np.real(test), np.real(vals), rtol=1e-05) - - for N, vals in zip(testNinteger, refvalsinteger["S3l2"]): - test = csf.S3l2(N) - np.testing.assert_allclose(test, vals, rtol=1e-05) - - -def test_S1111l20511(): - for N, vals in zip(testN, refvals["S1111l20511"]): - S1 = harmonics.harmonic_S1(N) - test = csf.S1111l20511(N, S1) - np.testing.assert_allclose(test, vals, rtol=3e-03) - - -def test_S1111l21051(): - for N, vals in zip(testN, refvals["S1111l21051"]): - S1 = harmonics.harmonic_S1(N) - H21 = hf.H21(N, S1) - test = csf.S1111l21051(N, S1, H21) - rtol = 6e-03 - if N == 100 + 5j: - rtol = 2e-01 - np.testing.assert_allclose(test, vals, rtol=rtol) - - -def test_S121l2051(): - for N, vals in zip(testN, refvals["S121l2051"]): - S1 = harmonics.harmonic_S1(N) - H23 = hf.H23(N, S1) - test = csf.S121l2051(N, S1, H23) - np.testing.assert_allclose(test, vals, rtol=2e-1) - - -def test_S31l205(): - for N, vals in zip(testN, refvals["S31l205"]): - S1 = harmonics.harmonic_S1(N) - S2 = harmonics.harmonic_S2(N) - S3 = harmonics.harmonic_S3(N) - test = csf.S31l205(N, S1, S2, S3) - # same as S3l2 for complex part - np.testing.assert_allclose(np.real(test), np.real(vals), rtol=1e-04) - - -def test_S211l2051_S211l2105_S22l205(): - for N, vals in zip( - testN, - np.array(refvals["S211l2051"]) - + np.array(refvals["S211l2105"]) - - np.array(refvals["S22l205"]), - ): - S1 = harmonics.harmonic_S1(N) - S2 = harmonics.harmonic_S2(N) - test = hf.H26(N, S1, S2) - rtol = 2e-02 - if N == 5j + 100: - rtol = 25e-02 - np.testing.assert_allclose(test, vals, rtol=rtol) - - -def test_S1111l21105_S112l2051_S112l2105_S121l2105_S13l205(): - for N, vals in zip( - testN, - np.array(refvals["S1111l21105"]) - + np.array(refvals["S112l2051"]) - - np.array(refvals["S112l2105"]) - + np.array(refvals["S121l2105"]) - - np.array(refvals["S13l205"]), - ): - S1 = harmonics.harmonic_S1(N) - S2 = harmonics.harmonic_S2(N) - S3 = harmonics.harmonic_S3(N) - H21 = hf.H21(N, S1) - H23 = hf.H23(N, S1) - H24 = hf.H24(N, S1) - H25 = hf.H25(N, S1, S2) - test = hf.H27(N, S1, S2, S3, H21, H23, H24, H25) - rtol = 5e-03 - if N == 5j + 100: - rtol = 15e-02 - np.testing.assert_allclose(test, vals, rtol=rtol) From c5219ecbad2660a8a46f587e351bc64aef39ac48 Mon Sep 17 00:00:00 2001 From: giacomomagni Date: Mon, 29 Nov 2021 17:32:00 +0100 Subject: [PATCH 66/71] Adding log parts to N3LO ome --- src/eko/matching_conditions/n3lo/__init__.py | 32 +- src/eko/matching_conditions/n3lo/aHg.py | 1677 ++++++++++++++++- src/eko/matching_conditions/n3lo/aHq.py | 515 ++++- src/eko/matching_conditions/n3lo/agg.py | 793 +++++++- src/eko/matching_conditions/n3lo/agq.py | 368 +++- src/eko/matching_conditions/n3lo/aqg.py | 229 ++- src/eko/matching_conditions/n3lo/aqqNS.py | 113 +- src/eko/matching_conditions/n3lo/aqqPS.py | 95 +- .../operator_matrix_element.py | 8 +- tests/test_matching_n3lo.py | 126 +- 10 files changed, 3863 insertions(+), 93 deletions(-) diff --git a/src/eko/matching_conditions/n3lo/__init__.py b/src/eko/matching_conditions/n3lo/__init__.py index ed15809c3..da7da07bf 100644 --- a/src/eko/matching_conditions/n3lo/__init__.py +++ b/src/eko/matching_conditions/n3lo/__init__.py @@ -14,8 +14,8 @@ from .aHq import A_Hq_3 -@nb.njit("c16[:,:](c16,c16[:],u4)", cache=True) -def A_singlet_3(n, sx_all, nf): +@nb.njit("c16[:,:](c16,c16[:],u4,f8)", cache=True) +def A_singlet_3(n, sx_all, nf, L): r""" Computes the |N3LO| singlet |OME|. @@ -33,6 +33,10 @@ def A_singlet_3(n, sx_all, nf): sx_all : numpy.ndarray List of harmonic sums containing: [S1 ... S5, Sm1 ... Sm5, S21, S2m1, Sm21, Sm2m1, S31, S221, Sm22, Sm211, Sm31] + nf : int + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` Returns ------- @@ -43,15 +47,15 @@ def A_singlet_3(n, sx_all, nf): smx = sx_all[5:10] s3x = sx_all[10:14] s4x = sx_all[14:] - A_hq = A_Hq_3(n, sx, smx, s3x, s4x, nf) - A_hg = A_Hg_3(n, sx, smx, s3x, s4x, nf) + A_hq = A_Hq_3(n, sx, smx, s3x, s4x, nf, L) + A_hg = A_Hg_3(n, sx, smx, s3x, s4x, nf, L) - A_gq = A_gq_3(n, sx, smx, s3x, s4x, nf) - A_gg = A_gg_3(n, sx, smx, s3x, s4x, nf) + A_gq = A_gq_3(n, sx, smx, s3x, s4x, nf, L) + A_gg = A_gg_3(n, sx, smx, s3x, s4x, nf, L) - A_qq_ps = A_qqPS_3(n, sx, nf) - A_qq_ns = A_qqNS_3(n, sx, smx, s3x, s4x, nf) - A_qg = A_qg_3(n, sx, smx, s3x, s4x, nf) + A_qq_ps = A_qqPS_3(n, sx, nf, L) + A_qq_ns = A_qqNS_3(n, sx, smx, s3x, s4x, nf, L) + A_qg = A_qg_3(n, sx, smx, s3x, s4x, nf, L) A_S_3 = np.array( [[A_gg, A_gq, 0.0], [A_qg, A_qq_ps + A_qq_ns, 0.0], [A_hg, A_hq, 0.0]], @@ -60,8 +64,8 @@ def A_singlet_3(n, sx_all, nf): return A_S_3 -@nb.njit("c16[:,:](c16,c16[:],u4)", cache=True) -def A_ns_3(n, sx_all, nf): +@nb.njit("c16[:,:](c16,c16[:],u4,f8)", cache=True) +def A_ns_3(n, sx_all, nf, L): r""" Computes the |N3LO| non-singlet |OME|. @@ -78,6 +82,10 @@ def A_ns_3(n, sx_all, nf): sx_all : numpy.ndarray List of harmonic sums containing: [S1 ... S5, Sm1 ... Sm5, S21, S2m1, Sm21, Sm2m1, S31, S221, Sm22, Sm211, Sm31] + nf : int + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` Returns ------- @@ -92,5 +100,5 @@ def A_ns_3(n, sx_all, nf): smx = sx_all[5:10] s3x = sx_all[10:14] s4x = sx_all[14:] - A_qq = A_qqNS_3(n, sx, smx, s3x, s4x, nf) + A_qq = A_qqNS_3(n, sx, smx, s3x, s4x, nf, L) return np.array([[A_qq, 0.0], [0 + 0j, 0 + 0j]], np.complex_) diff --git a/src/eko/matching_conditions/n3lo/aHg.py b/src/eko/matching_conditions/n3lo/aHg.py index ddb22bba6..5cf8308cd 100644 --- a/src/eko/matching_conditions/n3lo/aHg.py +++ b/src/eko/matching_conditions/n3lo/aHg.py @@ -6,8 +6,8 @@ from .aHgstfac import A_Hgstfac_3 -@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) -def A_Hg_3(n, sx, smx, s3x, s4x, nf): +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4,f8)", cache=True) +def A_Hg_3(n, sx, smx, s3x, s4x, nf, L): r""" Computes the |N3LO| singlet |OME| :math:`A_{Hg}^{S,(3)}(N)`. The experssion is presented in :cite:`Bierenbaum:2009mv` @@ -25,7 +25,9 @@ def A_Hg_3(n, sx, smx, s3x, s4x, nf): s4x : numpy.ndarray list S31, S221, Sm22, Sm211, Sm31 nf : int - numeber of active flavor below the threshold + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` Returns ------- @@ -40,7 +42,7 @@ def A_Hg_3(n, sx, smx, s3x, s4x, nf): Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] S21, Sm21 = s3x[0], s3x[2] S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] - return ( + a_Hg_l0 = ( A_Hgstfac_3(n, sx, smx, s3x, s4x, nf) + (1.0684950250307503 * (2.0 + n + np.power(n, 2))) / (n * (1.0 + n) * (2.0 + n)) @@ -2137,3 +2139,1670 @@ def A_Hg_3(n, sx, smx, s3x, s4x, nf): / (n * (1.0 + n) * (2.0 + n)) ) ) + a_Hg_l3 = ( + (0.8888888888888888 * (2.0 + n + np.power(n, 2))) / (n * (1.0 + n) * (2.0 + n)) + - 0.3333333333333333 + * nf + * ( + ( + 0.8888888888888888 + * (2.0 + n + np.power(n, 2)) + * ( + -24.0 + - 28.0 * n + - 38.0 * np.power(n, 2) + - 17.0 * np.power(n, 3) + - 1.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - (3.5555555555555554 * (2.0 + n + np.power(n, 2)) * S1) + / (n * (1.0 + n) * (2.0 + n)) + ) + - 0.75 + * nf + * ( + ( + -7.111111111111111 + * (1.0 + n + np.power(n, 2)) + * (2.0 + n + np.power(n, 2)) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + (3.5555555555555554 * (2.0 + n + np.power(n, 2)) * S1) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 0.3333333333333333 + * ( + ( + -1.7777777777777777 + * (2.0 + n + np.power(n, 2)) + * ( + -12.0 + - 20.0 * n + - 31.0 * np.power(n, 2) + - 16.0 * np.power(n, 3) + + 7.0 * np.power(n, 4) + + 18.0 * np.power(n, 5) + + 6.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + (14.222222222222221 * (2.0 + n + np.power(n, 2)) * S1) + / (n * (1.0 + n) * (2.0 + n)) + ) + - 0.75 + * ( + ( + -49.77777777777778 + * (1.0 + n + np.power(n, 2)) + * (2.0 + n + np.power(n, 2)) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + (24.88888888888889 * (2.0 + n + np.power(n, 2)) * S1) + / (n * (1.0 + n) * (2.0 + n)) + ) + - 0.8888888888888888 + * ( + ( + -0.6666666666666666 + * (2.0 + n + np.power(n, 2)) + * np.power(2.0 + 3.0 * n + 3.0 * np.power(n, 2), 2) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 5.333333333333333 + * (2.0 + n + np.power(n, 2)) + * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + * S1 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - (10.666666666666666 * (2.0 + n + np.power(n, 2)) * np.power(S1, 2)) + / (n * (1.0 + n) * (2.0 + n)) + ) + - 4.5 + * ( + ( + 1.7777777777777777 + * (1.0 + n + np.power(n, 2)) + * (2.0 + n + np.power(n, 2)) + * ( + -24.0 + - 46.0 * n + - 35.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 0.8888888888888888 + * (2.0 + n + np.power(n, 2)) + * ( + -48.0 + - 70.0 * n + - 59.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - (10.666666666666666 * (2.0 + n + np.power(n, 2)) * np.power(S1, 2)) + / (n * (1.0 + n) * (2.0 + n)) + ) + - 2.0 + * ( + ( + -0.2222222222222222 + * (2.0 + n + np.power(n, 2)) + * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + * ( + -48.0 + - 70.0 * n + - 59.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 0.8888888888888888 + * (2.0 + n + np.power(n, 2)) + * (6.0 + n + np.power(n, 2)) + * (4.0 + 7.0 * n + 7.0 * np.power(n, 2)) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + (21.333333333333332 * (2.0 + n + np.power(n, 2)) * np.power(S1, 2)) + / (n * (1.0 + n) * (2.0 + n)) + ) + ) + a_Hg_l2 = ( + 0.3333333333333333 + * ( + ( + -0.4444444444444444 + * ( + -1152.0 + - 3648.0 * n + - 6640.0 * np.power(n, 2) + - 11680.0 * np.power(n, 3) + - 13912.0 * np.power(n, 4) + - 9464.0 * np.power(n, 5) + + 383.0 * np.power(n, 6) + + 6505.0 * np.power(n, 7) + + 5730.0 * np.power(n, 8) + + 2894.0 * np.power(n, 9) + + 903.0 * np.power(n, 10) + + 129.0 * np.power(n, 11) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 3.5555555555555554 + * (18.0 + 37.0 * n + 14.0 * np.power(n, 2) + 5.0 * np.power(n, 3)) + * S1 + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * (4.0 * np.power(S1, 2) - 1.3333333333333333 * S2) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 0.3333333333333333 + * nf + * ( + ( + -0.4444444444444444 + * ( + 1152.0 + + 3456.0 * n + + 5456.0 * np.power(n, 2) + + 7328.0 * np.power(n, 3) + + 5096.0 * np.power(n, 4) + + 2236.0 * np.power(n, 5) + + 1463.0 * np.power(n, 6) + + 1513.0 * np.power(n, 7) + + 1290.0 * np.power(n, 8) + + 698.0 * np.power(n, 9) + + 231.0 * np.power(n, 10) + + 33.0 * np.power(n, 11) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 3.5555555555555554 + * (6.0 + 19.0 * n + 8.0 * np.power(n, 2) + 5.0 * np.power(n, 3)) + * S1 + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * (1.3333333333333333 * np.power(S1, 2) + 1.3333333333333333 * S2) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 0.75 + * ( + ( + -0.8888888888888888 + * ( + 384.0 + + 1696.0 * n + + 2928.0 * np.power(n, 2) + + 3484.0 * np.power(n, 3) + + 2740.0 * np.power(n, 4) + + 1731.0 * np.power(n, 5) + + 1262.0 * np.power(n, 6) + + 724.0 * np.power(n, 7) + + 270.0 * np.power(n, 8) + + 45.0 * np.power(n, 9) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + + ( + 3.5555555555555554 + * ( + 20.0 + - 14.0 * n + - 1.0 * np.power(n, 2) + + 20.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * S1 + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * (-4.0 * np.power(S1, 2) - 4.0 * S2 - 8.0 * Sm2) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 0.75 + * nf + * ( + ( + -0.8888888888888888 + * ( + -160.0 + - 672.0 * n + - 1012.0 * np.power(n, 2) + - 1120.0 * np.power(n, 3) + - 717.0 * np.power(n, 4) + - 182.0 * np.power(n, 5) + + 56.0 * np.power(n, 6) + + 54.0 * np.power(n, 7) + + 9.0 * np.power(n, 8) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 3.5555555555555554 + * ( + 20.0 + + 58.0 * n + + 47.0 * np.power(n, 2) + + 20.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * S1 + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -1.3333333333333333 * np.power(S1, 2) + - 1.3333333333333333 * S2 + - 2.6666666666666665 * Sm2 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 0.8888888888888888 + * ( + ( + 32.0 + + 128.0 * n + + 292.0 * np.power(n, 2) + + 528.0 * np.power(n, 3) + + 685.0 * np.power(n, 4) + + 636.0 * np.power(n, 5) + + 350.0 * np.power(n, 6) + + 132.0 * np.power(n, 7) + + 33.0 * np.power(n, 8) + ) + / (np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + - ( + 8.0 + * ( + 12.0 + + 34.0 * n + + 60.0 * np.power(n, 2) + + 84.0 * np.power(n, 3) + + 51.0 * np.power(n, 4) + + 18.0 * np.power(n, 5) + + 5.0 * np.power(n, 6) + ) + * S1 + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 4.0 + * ( + 20.0 + + 48.0 * n + + 43.0 * np.power(n, 2) + + 14.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + * np.power(S1, 2) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 12.0 + * (2.0 + n + np.power(n, 2)) + * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + * S2 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - (32.0 * (2.0 + n + np.power(n, 2)) * Sm2) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + 4.0 * np.power(S1, 3) + - 12.0 * S1 * S2 + - 8.0 * S3 + - 16.0 * S1 * Sm2 + + 16.0 * Sm21 + - 8.0 * Sm3 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 2.0 + * ( + ( + 0.1111111111111111 + * ( + 2304.0 + - 2864.0 * n + - 16272.0 * np.power(n, 2) + - 24608.0 * np.power(n, 3) + - 12692.0 * np.power(n, 4) + + 6675.0 * np.power(n, 5) + + 12206.0 * np.power(n, 6) + + 7636.0 * np.power(n, 7) + + 2934.0 * np.power(n, 8) + + 489.0 * np.power(n, 9) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 0.8888888888888888 + * ( + 144.0 + + 24.0 * n + - 668.0 * np.power(n, 2) + - 314.0 * np.power(n, 3) + - 2.0 * np.power(n, 4) + + 119.0 * np.power(n, 5) + + 613.0 * np.power(n, 6) + + 635.0 * np.power(n, 7) + + 273.0 * np.power(n, 8) + + 40.0 * np.power(n, 9) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + + ( + 2.6666666666666665 + * ( + 36.0 + + 56.0 * n + + 29.0 * np.power(n, 2) + - 137.0 * np.power(n, 3) + - 120.0 * np.power(n, 4) + - 9.0 * np.power(n, 5) + + np.power(n, 6) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + 2.6666666666666665 + * (2.0 + n + np.power(n, 2)) + * ( + 18.0 + + 7.0 * n + + 8.0 * np.power(n, 2) + + 2.0 * np.power(n, 3) + + np.power(n, 4) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 * np.power(S1, 3) + + 4.0 * S3 + + 6.0 * Sm2 + - 8.0 * Sm21 + + 4.0 * Sm3 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + + 4.5 + * ( + ( + 1.7777777777777777 + * ( + -576.0 + - 2592.0 * n + - 5296.0 * np.power(n, 2) + - 6992.0 * np.power(n, 3) + - 6012.0 * np.power(n, 4) + - 4462.0 * np.power(n, 5) + - 3841.0 * np.power(n, 6) + - 4619.0 * np.power(n, 7) + - 4428.0 * np.power(n, 8) + - 2325.0 * np.power(n, 9) + - 511.0 * np.power(n, 10) + + 101.0 * np.power(n, 11) + + 72.0 * np.power(n, 12) + + 9.0 * np.power(n, 13) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 4) + ) + + ( + 0.8888888888888888 + * ( + -576.0 + - 1296.0 * n + + 968.0 * np.power(n, 2) + + 2568.0 * np.power(n, 3) + + 2238.0 * np.power(n, 4) + - 325.0 * np.power(n, 5) + - 521.0 * np.power(n, 6) + + 788.0 * np.power(n, 7) + + 830.0 * np.power(n, 8) + + 425.0 * np.power(n, 9) + + 85.0 * np.power(n, 10) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 1.3333333333333333 + * ( + -48.0 + - 116.0 * n + + 4.0 * np.power(n, 2) + - 85.0 * np.power(n, 3) + - 87.0 * np.power(n, 4) + + 33.0 * np.power(n, 5) + + 11.0 * np.power(n, 6) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 1.3333333333333333 + * (2.0 + n + np.power(n, 2)) + * ( + -72.0 + - 94.0 * n + - 83.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 2.6666666666666665 + * (2.0 + n + np.power(n, 2)) + * ( + -48.0 + - 70.0 * n + - 59.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * Sm2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + 4.0 * np.power(S1, 3) + + 12.0 * S1 * S2 + + 4.0 * S3 + + 16.0 * S1 * Sm2 + - 8.0 * Sm21 + + 4.0 * Sm3 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + ) + a_Hg_l1 = ( + 0.3333333333333333 + * ( + ( + -0.07407407407407407 + * ( + -34560.0 + - 144000.0 * n + - 299712.0 * np.power(n, 2) + - 453440.0 * np.power(n, 3) + - 534656.0 * np.power(n, 4) + - 492936.0 * np.power(n, 5) + - 435356.0 * np.power(n, 6) + - 228072.0 * np.power(n, 7) + + 154773.0 * np.power(n, 8) + + 398930.0 * np.power(n, 9) + + 371423.0 * np.power(n, 10) + + 214620.0 * np.power(n, 11) + + 80795.0 * np.power(n, 12) + + 18018.0 * np.power(n, 13) + + 1773.0 * np.power(n, 14) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + + ( + 0.5925925925925926 + * ( + 192.0 + + 592.0 * n + + 786.0 * np.power(n, 2) + + 163.0 * np.power(n, 3) + + 29.0 * np.power(n, 4) + ) + * S1 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 1.7777777777777777 + * (18.0 + 59.0 * n + 31.0 * np.power(n, 2) + 10.0 * np.power(n, 3)) + * np.power(S1, 2) + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - ( + 5.333333333333333 + * ( + -2.0 + - 5.0 * n + + 42.0 * np.power(n, 2) + + 39.0 * np.power(n, 3) + + 2.0 * np.power(n, 4) + ) + * S2 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * (1.3333333333333333 * np.power(S1, 3) + 4.0 * S1 * S2 - 8.0 * S3) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + - 0.3333333333333333 + * nf + * ( + ( + 0.07407407407407407 + * ( + -34560.0 + - 158976.0 * n + - 355584.0 * np.power(n, 2) + - 562304.0 * np.power(n, 3) + - 735104.0 * np.power(n, 4) + - 694320.0 * np.power(n, 5) + - 490544.0 * np.power(n, 6) + - 207408.0 * np.power(n, 7) + + 82971.0 * np.power(n, 8) + + 205070.0 * np.power(n, 9) + + 159437.0 * np.power(n, 10) + + 77604.0 * np.power(n, 11) + + 25877.0 * np.power(n, 12) + + 5454.0 * np.power(n, 13) + + 531.0 * np.power(n, 14) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + - ( + 1.1851851851851851 + * ( + 78.0 + + 251.0 * n + + 303.0 * np.power(n, 2) + + 77.0 * np.power(n, 3) + + 19.0 * np.power(n, 4) + ) + * S1 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 3.5555555555555554 + * (6.0 + 22.0 * n + 11.0 * np.power(n, 2) + 5.0 * np.power(n, 3)) + * np.power(S1, 2) + ) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + + ( + 5.333333333333333 + * ( + -48.0 + - 72.0 * n + - 108.0 * np.power(n, 2) + - 128.0 * np.power(n, 3) + - 123.0 * np.power(n, 4) + + 8.0 * np.power(n, 5) + + 62.0 * np.power(n, 6) + + 24.0 * np.power(n, 7) + + np.power(n, 8) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + 0.8888888888888888 * np.power(S1, 3) + + 2.6666666666666665 * S1 * S2 + - 6.222222222222222 * S3 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + - 0.75 + * ( + ( + 0.5925925925925926 + * ( + 288.0 + + 1008.0 * n + + 80.0 * np.power(n, 2) + - 4560.0 * np.power(n, 3) + - 19122.0 * np.power(n, 4) + - 34963.0 * np.power(n, 5) + - 37157.0 * np.power(n, 6) + - 21724.0 * np.power(n, 7) + - 2662.0 * np.power(n, 8) + + 5168.0 * np.power(n, 9) + + 3634.0 * np.power(n, 10) + + 1035.0 * np.power(n, 11) + + 111.0 * np.power(n, 12) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 4) + ) + + ( + 0.5925925925925926 + * ( + 536.0 + + 1516.0 * n + + 3186.0 * np.power(n, 2) + + 3271.0 * np.power(n, 3) + + 1692.0 * np.power(n, 4) + + 487.0 * np.power(n, 5) + + 76.0 * np.power(n, 6) + ) + * S1 + ) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - ( + 3.5555555555555554 + * ( + 26.0 + + 82.0 * n + + 65.0 * np.power(n, 2) + + 23.0 * np.power(n, 3) + + 5.0 * np.power(n, 4) + ) + * np.power(S1, 2) + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - ( + 3.5555555555555554 + * ( + 48.0 + + 34.0 * n + + 40.0 * np.power(n, 2) + + 35.0 * np.power(n, 3) + + 84.0 * np.power(n, 4) + + 42.0 * np.power(n, 5) + + 5.0 * np.power(n, 6) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + (42.666666666666664 * (-4.0 - 1.0 * n + np.power(n, 2)) * Sm2) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - (7.111111111111111 * (10.0 + 8.0 * n + 5.0 * np.power(n, 2)) * Sm2) + / (n * (1.0 + n) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -1.3333333333333333 * np.power(S1, 3) + - 6.666666666666667 * S1 * S2 + - 5.333333333333333 * S21 + - 8.0 * S3 + - 10.666666666666666 * S1 * Sm2 + + 10.666666666666666 * Sm21 + - 10.666666666666666 * Sm3 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + - 0.75 + * nf + * ( + ( + 0.2962962962962963 + * ( + 576.0 + + 4128.0 * n + + 12416.0 * np.power(n, 2) + + 22080.0 * np.power(n, 3) + + 16644.0 * np.power(n, 4) + - 2110.0 * np.power(n, 5) + - 15710.0 * np.power(n, 6) + - 8917.0 * np.power(n, 7) + + 7139.0 * np.power(n, 8) + + 11990.0 * np.power(n, 9) + + 6742.0 * np.power(n, 10) + + 1845.0 * np.power(n, 11) + + 201.0 * np.power(n, 12) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 4) + ) + + ( + 0.5925925925925926 + * ( + 232.0 + + 776.0 * n + + 1878.0 * np.power(n, 2) + + 1820.0 * np.power(n, 3) + + 777.0 * np.power(n, 4) + + 176.0 * np.power(n, 5) + + 29.0 * np.power(n, 6) + ) + * S1 + ) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - ( + 1.7777777777777777 + * ( + 46.0 + + 131.0 * n + + 106.0 * np.power(n, 2) + + 43.0 * np.power(n, 3) + + 10.0 * np.power(n, 4) + ) + * np.power(S1, 2) + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - ( + 1.7777777777777777 + * ( + 48.0 + + 14.0 * n + + 17.0 * np.power(n, 2) + + 31.0 * np.power(n, 3) + + 105.0 * np.power(n, 4) + + 63.0 * np.power(n, 5) + + 10.0 * np.power(n, 6) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + (21.333333333333332 * (-4.0 - 1.0 * n + np.power(n, 2)) * Sm2) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - (7.111111111111111 * (10.0 + 8.0 * n + 5.0 * np.power(n, 2)) * Sm2) + / (n * (1.0 + n) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -0.8888888888888888 * np.power(S1, 3) + - 2.6666666666666665 * S1 * S2 + - 5.333333333333333 * S21 + - 4.444444444444445 * S3 + - 5.333333333333333 * S1 * Sm2 + + 5.333333333333333 * Sm21 + - 8.0 * Sm3 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + - 2.0 + * ( + ( + -7.212341418957566 + * ( + -248.0 + + 12.0 * n + - 214.0 * np.power(n, 2) + - 407.0 * np.power(n, 3) + - 91.0 * np.power(n, 4) + + 135.0 * np.power(n, 5) + + 45.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 0.018518518518518517 + * ( + 27648.0 + + 143424.0 * n + + 372192.0 * np.power(n, 2) + + 664624.0 * np.power(n, 3) + + 606016.0 * np.power(n, 4) + + 189820.0 * np.power(n, 5) + + 204230.0 * np.power(n, 6) + + 650149.0 * np.power(n, 7) + + 820775.0 * np.power(n, 8) + + 532170.0 * np.power(n, 9) + + 206656.0 * np.power(n, 10) + + 53973.0 * np.power(n, 11) + + 7299.0 * np.power(n, 12) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 0.2962962962962963 + * ( + 1944.0 + + 6156.0 * n + + 7122.0 * np.power(n, 2) + + 13.0 * np.power(n, 3) + - 2242.0 * np.power(n, 4) + + 4008.0 * np.power(n, 5) + + 6764.0 * np.power(n, 6) + + 4206.0 * np.power(n, 7) + + 1586.0 * np.power(n, 8) + + 251.0 * np.power(n, 9) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 0.4444444444444444 + * ( + 864.0 + + 2712.0 * n + + 3116.0 * np.power(n, 2) + + 4106.0 * np.power(n, 3) + + 2003.0 * np.power(n, 4) + - 1202.0 * np.power(n, 5) + - 592.0 * np.power(n, 6) + + 568.0 * np.power(n, 7) + + 441.0 * np.power(n, 8) + + 80.0 * np.power(n, 9) + ) + * np.power(S1, 2) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + + ( + 0.8888888888888888 + * ( + -144.0 + - 496.0 * n + - 866.0 * np.power(n, 2) + - 499.0 * np.power(n, 3) + - 46.0 * np.power(n, 4) + + 11.0 * np.power(n, 5) + ) + * np.power(S1, 3) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + 1.3333333333333333 + * ( + 480.0 + + 1944.0 * n + + 4020.0 * np.power(n, 2) + + 6446.0 * np.power(n, 3) + + 7513.0 * np.power(n, 4) + + 4345.0 * np.power(n, 5) + + 462.0 * np.power(n, 6) + - 424.0 * np.power(n, 7) + - 43.0 * np.power(n, 8) + + 25.0 * np.power(n, 9) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 2.6666666666666665 + * (3.0 + n) + * ( + 8.0 + + 8.0 * n + + 52.0 * np.power(n, 2) + + 93.0 * np.power(n, 3) + + 114.0 * np.power(n, 4) + + 13.0 * np.power(n, 5) + ) + * S1 + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + (48.0 * np.power(2.0 + n + np.power(n, 2), 2) * S21) + / ((-1.0 + n) * n * (1.0 + n) * np.power(2.0 + n, 2)) + - ( + 0.8888888888888888 + * ( + 432.0 + - 452.0 * n + - 128.0 * np.power(n, 2) + + 977.0 * np.power(n, 3) + + 627.0 * np.power(n, 4) + + 195.0 * np.power(n, 5) + + 77.0 * np.power(n, 6) + ) + * S3 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 16.0 + * (-4.0 - 1.0 * n + np.power(n, 2)) + * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + * Sm2 + ) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + - ( + 16.0 + * ( + 12.0 + - 10.0 * n + - 54.0 * np.power(n, 2) + - 87.0 * np.power(n, 3) + - 40.0 * np.power(n, 4) + + 3.0 * np.power(n, 5) + ) + * Sm2 + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 64.0 + * (-2.0 - 14.0 * n - 13.0 * np.power(n, 2) + np.power(n, 3)) + * S1 + * Sm2 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 16.0 + * ( + 8.0 + + 20.0 * n + + 46.0 * np.power(n, 2) + + 27.0 * np.power(n, 3) + + 8.0 * np.power(n, 4) + + 3.0 * np.power(n, 5) + ) + * S1 + * Sm2 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + 16.0 + * ( + -12.0 + + 32.0 * n + + 39.0 * np.power(n, 2) + + 2.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + * Sm21 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + (2.0 + n + np.power(n, 2)) + * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + * (-7.212341418957566 - 8.0 * Sm3) + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 16.0 + * ( + 8.0 + - 6.0 * n + - 5.0 * np.power(n, 2) + + 8.0 * np.power(n, 3) + + 3.0 * np.power(n, 4) + ) + * Sm3 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + 28.849365675830263 * S1 + - 4.0 * np.power(S1, 4) + - 36.0 * np.power(S1, 2) * S2 + + 8.0 * np.power(S2, 2) + - 24.0 * S211 + - 8.0 * S31 + - 40.0 * np.power(S1, 2) * Sm2 + - 12.0 * np.power(Sm2, 2) + + S1 * (48.0 * S21 - 32.0 * S3 + 16.0 * Sm21) + + 32.0 * Sm211 + - 8.0 * Sm22 + - 8.0 * S1 * Sm3 + - 20.0 * Sm4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + - 0.8888888888888888 + * ( + (57.69873135166053 * (-1.0 + n) * (-2.0 + 3.0 * n + 3.0 * np.power(n, 2))) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + - ( + 0.5 + * ( + 96.0 + + 400.0 * n + + 1296.0 * np.power(n, 2) + + 3168.0 * np.power(n, 3) + + 5062.0 * np.power(n, 4) + + 6277.0 * np.power(n, 5) + + 6853.0 * np.power(n, 6) + + 5026.0 * np.power(n, 7) + + 2368.0 * np.power(n, 8) + + 793.0 * np.power(n, 9) + + 149.0 * np.power(n, 10) + ) + ) + / (np.power(n, 5) * np.power(1.0 + n, 5) * (2.0 + n)) + + ( + 8.0 + * ( + 24.0 + + 92.0 * n + + 172.0 * np.power(n, 2) + + 332.0 * np.power(n, 3) + + 529.0 * np.power(n, 4) + + 441.0 * np.power(n, 5) + + 179.0 * np.power(n, 6) + + 29.0 * np.power(n, 7) + + 2.0 * np.power(n, 8) + ) + * S1 + ) + / (np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + - ( + 8.0 + * ( + 22.0 + + 79.0 * n + + 135.0 * np.power(n, 2) + + 160.0 * np.power(n, 3) + + 97.0 * np.power(n, 4) + + 26.0 * np.power(n, 5) + + 5.0 * np.power(n, 6) + ) + * np.power(S1, 2) + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + (64.0 * (1.0 + n) * np.power(S1, 3)) / (np.power(n, 2) * (2.0 + n)) + + ( + 4.0 + * ( + 28.0 + + 70.0 * n + + 96.0 * np.power(n, 2) + + 157.0 * np.power(n, 3) + + 75.0 * np.power(n, 4) + + 39.0 * np.power(n, 5) + + 23.0 * np.power(n, 6) + ) + * S2 + ) + / (np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 16.0 + * ( + -4.0 + - 18.0 * n + + 3.0 * np.power(n, 2) + + 10.0 * np.power(n, 3) + + np.power(n, 4) + ) + * S1 + * S2 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - (64.0 * (2.0 + n + np.power(n, 2)) * S21) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 8.0 + * (2.0 + 5.0 * n + np.power(n, 2)) + * (2.0 - 1.0 * n + 3.0 * np.power(n, 2)) + * S3 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 32.0 + * ( + 8.0 + - 2.0 * n + + np.power(n, 2) + - 1.0 * np.power(n, 3) + + 4.0 * np.power(n, 4) + + 2.0 * np.power(n, 5) + ) + * Sm2 + ) + / (np.power(n, 3) * np.power(1.0 + n, 2) * (2.0 + n)) + + ((2.0 - 1.0 * n + np.power(n, 2)) * (-128.0 * S1 * Sm2 + 128.0 * Sm21)) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - (64.0 * (-1.0 + n) * Sm3) / (np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + 2.0 * np.power(S1, 4) + + 4.0 * np.power(S1, 2) * S2 + + 6.0 * np.power(S2, 2) + + 24.0 * S211 + + S1 * (-32.0 * S21 + 24.0 * S3) + - 8.0 * S31 + + 20.0 * S4 + + 16.0 * S2 * Sm2 + + 8.0 * np.power(Sm2, 2) + - 16.0 * Sm22 + + 32.0 * S1 * Sm3 + - 32.0 * Sm31 + + 40.0 * Sm4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + - 4.5 + * ( + ( + 2.4041138063191885 + * ( + -624.0 + - 596.0 * n + - 956.0 * np.power(n, 2) + - 637.0 * np.power(n, 3) + - 111.0 * np.power(n, 4) + + 249.0 * np.power(n, 5) + + 83.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 0.14814814814814814 + * ( + 34560.0 + + 211392.0 * n + + 604032.0 * np.power(n, 2) + + 1.099952e6 * np.power(n, 3) + + 1.506496e6 * np.power(n, 4) + + 1.640548e6 * np.power(n, 5) + + 1.596952e6 * np.power(n, 6) + + 1.332497e6 * np.power(n, 7) + + 702425.0 * np.power(n, 8) + - 16829.0 * np.power(n, 9) + - 322813.0 * np.power(n, 10) + - 155710.0 * np.power(n, 11) + + 66350.0 * np.power(n, 12) + + 101719.0 * np.power(n, 13) + + 47251.0 * np.power(n, 14) + + 10527.0 * np.power(n, 15) + + 939.0 * np.power(n, 16) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 5) + ) + - ( + 0.2962962962962963 + * ( + 432.0 + + 7344.0 * n + + 4968.0 * np.power(n, 2) + - 26584.0 * np.power(n, 3) + - 33249.0 * np.power(n, 4) + - 44369.0 * np.power(n, 5) + - 71221.0 * np.power(n, 6) + - 71723.0 * np.power(n, 7) + - 31716.0 * np.power(n, 8) + + 13564.0 * np.power(n, 9) + + 22254.0 * np.power(n, 10) + + 9908.0 * np.power(n, 11) + + 2368.0 * np.power(n, 12) + + 296.0 * np.power(n, 13) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 4) + ) + + ( + 0.4444444444444444 + * ( + -864.0 + - 2016.0 * n + + 1132.0 * np.power(n, 2) + + 5904.0 * np.power(n, 3) + + 561.0 * np.power(n, 4) + - 4745.0 * np.power(n, 5) + - 448.0 * np.power(n, 6) + + 2710.0 * np.power(n, 7) + + 1897.0 * np.power(n, 8) + + 883.0 * np.power(n, 9) + + 170.0 * np.power(n, 10) + ) + * np.power(S1, 2) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 0.8888888888888888 + * ( + 8.0 + - 218.0 * n + - 139.0 * np.power(n, 2) + + 26.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * np.power(S1, 3) + ) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + ( + 0.4444444444444444 + * ( + -2016.0 + - 6240.0 * n + - 5324.0 * np.power(n, 2) + - 2352.0 * np.power(n, 3) + - 861.0 * np.power(n, 4) + - 3047.0 * np.power(n, 5) + - 2692.0 * np.power(n, 6) + + 2506.0 * np.power(n, 7) + + 3091.0 * np.power(n, 8) + + 1213.0 * np.power(n, 9) + + 170.0 * np.power(n, 10) + ) + * S2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 2.6666666666666665 + * ( + -240.0 + - 368.0 * n + - 254.0 * np.power(n, 2) + - 319.0 * np.power(n, 3) + - 285.0 * np.power(n, 4) + + 15.0 * np.power(n, 5) + + 11.0 * np.power(n, 6) + ) + * S1 + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 5.333333333333333 + * (2.0 + n + np.power(n, 2)) + * ( + 24.0 + + 2.0 * n + + 13.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * S21 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 0.8888888888888888 + * ( + -1188.0 + - 1336.0 * n + - 1561.0 * np.power(n, 2) + - 899.0 * np.power(n, 3) + - 420.0 * np.power(n, 4) + + 165.0 * np.power(n, 5) + + 55.0 * np.power(n, 6) + ) + * S3 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 5.333333333333333 + * (-4.0 - 1.0 * n + np.power(n, 2)) + * ( + -24.0 + - 46.0 * n + - 35.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * Sm2 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + ( + 1.7777777777777777 + * ( + 648.0 + + 2916.0 * n + + 3802.0 * np.power(n, 2) + + 2731.0 * np.power(n, 3) + + 1381.0 * np.power(n, 4) + + 1517.0 * np.power(n, 5) + + 2086.0 * np.power(n, 6) + + 1508.0 * np.power(n, 7) + + 597.0 * np.power(n, 8) + + 94.0 * np.power(n, 9) + ) + * Sm2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 32.0 + * ( + -12.0 + + 4.0 * n + + 13.0 * np.power(n, 2) + - 32.0 * np.power(n, 3) + - 23.0 * np.power(n, 4) + + 2.0 * np.power(n, 5) + ) + * S1 + * Sm2 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 5.333333333333333 + * ( + -48.0 + - 68.0 * n + - 24.0 * np.power(n, 2) + - 49.0 * np.power(n, 3) + + 34.0 * np.power(n, 4) + + 11.0 * np.power(n, 5) + ) + * S1 + * Sm2 + ) + / ((-1.0 + n) * np.power(n, 2) * (1.0 + n) * np.power(2.0 + n, 2)) + + ( + 5.333333333333333 + * ( + -72.0 + - 92.0 * n + - 194.0 * np.power(n, 2) + - 361.0 * np.power(n, 3) + - 189.0 * np.power(n, 4) + + 33.0 * np.power(n, 5) + + 11.0 * np.power(n, 6) + ) + * Sm21 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + -24.0 + - 46.0 * n + - 35.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + * (-2.4041138063191885 - 2.6666666666666665 * Sm3) + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 5.333333333333333 + * ( + -108.0 + - 176.0 * n + - 263.0 * np.power(n, 2) + - 247.0 * np.power(n, 3) + - 114.0 * np.power(n, 4) + + 33.0 * np.power(n, 5) + + 11.0 * np.power(n, 6) + ) + * Sm3 + ) + / ( + (-1.0 + n) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -28.849365675830263 * S1 + + 2.0 * np.power(S1, 4) + + 32.0 * np.power(S1, 2) * S2 + + 2.0 * np.power(S2, 2) + + 16.0 * S31 + + 4.0 * S4 + + (40.0 * np.power(S1, 2) + 16.0 * S2) * Sm2 + + 12.0 * np.power(Sm2, 2) + + S1 * (-16.0 * S21 + 40.0 * S3 - 80.0 * Sm21) + + 96.0 * Sm211 + - 56.0 * Sm22 + + 72.0 * S1 * Sm3 + - 64.0 * Sm31 + + 44.0 * Sm4 + ) + ) + / (n * (1.0 + n) * (2.0 + n)) + ) + ) + return a_Hg_l0 + a_Hg_l1 * L + a_Hg_l2 * L ** 2 + a_Hg_l3 * L ** 3 diff --git a/src/eko/matching_conditions/n3lo/aHq.py b/src/eko/matching_conditions/n3lo/aHq.py index 9b97dc608..0ba62b418 100644 --- a/src/eko/matching_conditions/n3lo/aHq.py +++ b/src/eko/matching_conditions/n3lo/aHq.py @@ -1,19 +1,15 @@ # -*- coding: utf-8 -*- # pylint: disable=too-many-lines -"""This module contains the |OME| aHq, the experssions are taken from """ import numpy as np import numba as nb -@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) -def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4,f8)", cache=True) +def A_Hq_3(n, sx, smx, s3x, s4x, nf, L): # pylint: disable=too-many-locals r""" Computes the |N3LO| singlet |OME| :math:`A_{Hq}^{S,(3)}(N)`. The experssion is presented in :cite:`Ablinger_2015` (eq 5.1) and :cite:`Blumlein:2017wxd` (eq 3.1). - It contains generalized harmonics sums, which are computed inside - :ref:`eko.matching_conditions.n3lo.cs_functions` and use the libary - mpmath which is not compatible with numba. Parameters ---------- @@ -28,7 +24,9 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals s4x : numpy.ndarray list S31, S221, Sm22, Sm211, Sm31 nf : int - numeber of active flavor below the threshold + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` Returns ------- @@ -164,7 +162,7 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals - 0.0116772 * np.log(n) ** 3 ) - return ( + a_Hq_l0 = ( 0.3333333333333333 * nf * ( @@ -1636,3 +1634,504 @@ def A_Hq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) ) ) + a_Hq_l3 = ( + (4.7407407407407405 * np.power(2.0 + n + np.power(n, 2), 2)) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + (1.1851851851851851 * np.power(2.0 + n + np.power(n, 2), 2) * nf) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - 0.8888888888888888 + * ( + ( + 1.3333333333333333 + * np.power(2.0 + n + np.power(n, 2), 2) + * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - (5.333333333333333 * np.power(2.0 + n + np.power(n, 2), 2) * S1) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - 2.0 + * ( + ( + 0.8888888888888888 + * np.power(2.0 + n + np.power(n, 2), 2) + * ( + -12.0 + - 34.0 * n + - 23.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + (5.333333333333333 * np.power(2.0 + n + np.power(n, 2), 2) * S1) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) + a_Hq_l2 = ( + 0.3333333333333333 + * nf + * ( + ( + 3.5555555555555554 + * ( + -24.0 + - 20.0 * n + + 58.0 * np.power(n, 2) + + 61.0 * np.power(n, 3) + + 85.0 * np.power(n, 4) + + 83.0 * np.power(n, 5) + + 37.0 * np.power(n, 6) + + 8.0 * np.power(n, 7) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - (10.666666666666666 * np.power(2.0 + n + np.power(n, 2), 2) * S1) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 0.3333333333333333 + * ( + ( + -3.5555555555555554 + * ( + 24.0 + + 124.0 * n + + 162.0 * np.power(n, 2) + + 193.0 * np.power(n, 3) + + 84.0 * np.power(n, 4) + + 29.0 * np.power(n, 5) + + 8.0 * np.power(n, 6) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + (10.666666666666666 * np.power(2.0 + n + np.power(n, 2), 2) * S1) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 0.8888888888888888 + * ( + ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 + - 20.0 * n + - 26.0 * np.power(n, 2) + - 23.0 * np.power(n, 3) + + 7.0 * np.power(n, 4) + + 15.0 * np.power(n, 5) + + 7.0 * np.power(n, 6) + ) + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + - ( + 8.0 + * np.power(2.0 + n + np.power(n, 2), 2) + * (-2.0 + n + 5.0 * np.power(n, 2)) + * S1 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + (16.0 * np.power(2.0 + n + np.power(n, 2), 2) * S2) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 2.0 + * ( + ( + -0.8888888888888888 + * ( + 576.0 + + 2832.0 * n + + 4976.0 * np.power(n, 2) + + 4392.0 * np.power(n, 3) + + 2476.0 * np.power(n, 4) + + 1917.0 * np.power(n, 5) + + 1457.0 * np.power(n, 6) + + 2428.0 * np.power(n, 7) + + 3402.0 * np.power(n, 8) + + 2281.0 * np.power(n, 9) + + 793.0 * np.power(n, 10) + + 118.0 * np.power(n, 11) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 2.6666666666666665 + * (2.0 + n + np.power(n, 2)) + * ( + -24.0 + - 80.0 * n + + 40.0 * np.power(n, 2) + + 89.0 * np.power(n, 3) + + 51.0 * np.power(n, 4) + + 51.0 * np.power(n, 5) + + 17.0 * np.power(n, 6) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + (np.power(2.0 + n + np.power(n, 2), 2) * (16.0 * S2 + 32.0 * Sm2)) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) + a_Hq_l1 = ( + 0.3333333333333333 + * ( + ( + 2.3703703703703702 + * ( + 144.0 + + 336.0 * n + + 352.0 * np.power(n, 2) + + 820.0 * np.power(n, 3) + + 2379.0 * np.power(n, 4) + + 2874.0 * np.power(n, 5) + + 2431.0 * np.power(n, 6) + + 1914.0 * np.power(n, 7) + + 1059.0 * np.power(n, 8) + + 320.0 * np.power(n, 9) + + 43.0 * np.power(n, 10) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 7.111111111111111 + * ( + -24.0 + - 20.0 * n + + 58.0 * np.power(n, 2) + + 61.0 * np.power(n, 3) + + 85.0 * np.power(n, 4) + + 83.0 * np.power(n, 5) + + 37.0 * np.power(n, 6) + + 8.0 * np.power(n, 7) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 1.0 + * np.power(2.0 + n + np.power(n, 2), 2) + * (-10.666666666666666 * np.power(S1, 2) - 32.0 * S2) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - 0.3333333333333333 + * nf + * ( + ( + -1.1851851851851851 + * ( + 288.0 + + 672.0 * n + + 16.0 * np.power(n, 2) + - 1232.0 * np.power(n, 3) + - 654.0 * np.power(n, 4) + - 510.0 * np.power(n, 5) + - 218.0 * np.power(n, 6) + + 912.0 * np.power(n, 7) + + 939.0 * np.power(n, 8) + + 320.0 * np.power(n, 9) + + 43.0 * np.power(n, 10) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + + ( + 3.5555555555555554 + * ( + -48.0 + - 104.0 * n + - 56.0 * np.power(n, 2) + - 86.0 * np.power(n, 3) + - 11.0 * np.power(n, 4) + + 68.0 * np.power(n, 5) + + 37.0 * np.power(n, 6) + + 8.0 * np.power(n, 7) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * (-5.333333333333333 * np.power(S1, 2) - 26.666666666666668 * S2) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - 0.8888888888888888 + * ( + ( + -4.0 + * ( + 288.0 + + 1712.0 * n + + 4656.0 * np.power(n, 2) + + 8248.0 * np.power(n, 3) + + 10938.0 * np.power(n, 4) + + 10519.0 * np.power(n, 5) + + 7642.0 * np.power(n, 6) + + 5020.0 * np.power(n, 7) + + 3520.0 * np.power(n, 8) + + 2328.0 * np.power(n, 9) + + 1107.0 * np.power(n, 10) + + 305.0 * np.power(n, 11) + + 37.0 * np.power(n, 12) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 3) + ) + + ( + 8.0 + * ( + 192.0 + + 768.0 * n + + 1488.0 * np.power(n, 2) + + 1784.0 * np.power(n, 3) + + 1560.0 * np.power(n, 4) + + 822.0 * np.power(n, 5) + + 454.0 * np.power(n, 6) + + 567.0 * np.power(n, 7) + + 427.0 * np.power(n, 8) + + 143.0 * np.power(n, 9) + + 19.0 * np.power(n, 10) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * (6.0 + 9.0 * n + 4.0 * np.power(n, 2) + 5.0 * np.power(n, 3)) + * np.power(S1, 2) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 4.0 + * ( + -96.0 + - 296.0 * n + - 500.0 * np.power(n, 2) + - 658.0 * np.power(n, 3) + - 449.0 * np.power(n, 4) + - 133.0 * np.power(n, 5) + - 15.0 * np.power(n, 6) + + 3.0 * np.power(n, 7) + ) + * S2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + 115.39746270332105 + + 2.6666666666666665 * np.power(S1, 3) + - 24.0 * S1 * S2 + + 32.0 * S21 + - 26.666666666666668 * S3 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - 2.0 + * ( + ( + 0.2962962962962963 + * ( + -8640.0 + - 56448.0 * n + - 150864.0 * np.power(n, 2) + - 225808.0 * np.power(n, 3) + - 250212.0 * np.power(n, 4) + - 241600.0 * np.power(n, 5) + - 206883.0 * np.power(n, 6) + - 156761.0 * np.power(n, 7) + - 125240.0 * np.power(n, 8) + - 72944.0 * np.power(n, 9) + + 9045.0 * np.power(n, 10) + + 43489.0 * np.power(n, 11) + + 25572.0 * np.power(n, 12) + + 6560.0 * np.power(n, 13) + + 686.0 * np.power(n, 14) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + - ( + 0.8888888888888888 + * ( + 72.0 + + 924.0 * n + + 418.0 * np.power(n, 2) + - 3167.0 * np.power(n, 3) + - 3105.0 * np.power(n, 4) + - 2106.0 * np.power(n, 5) + - 2555.0 * np.power(n, 6) + - 438.0 * np.power(n, 7) + + 1110.0 * np.power(n, 8) + + 647.0 * np.power(n, 9) + + 136.0 * np.power(n, 10) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 2) + ) + + ( + 1.3333333333333333 + * (2.0 + n + np.power(n, 2)) + * ( + -12.0 + - 16.0 * n + + 41.0 * np.power(n, 2) + - 6.0 * np.power(n, 3) + + 17.0 * np.power(n, 4) + ) + * np.power(S1, 2) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 2) + * (2.0 + n) + ) + + ( + 1.3333333333333333 + * (2.0 + n + np.power(n, 2)) + * ( + -120.0 + - 412.0 * n + - 238.0 * np.power(n, 2) + + 31.0 * np.power(n, 3) + + 45.0 * np.power(n, 4) + + 189.0 * np.power(n, 5) + + 73.0 * np.power(n, 6) + ) + * S2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 2.6666666666666665 + * (2.0 + n + np.power(n, 2)) + * (74.0 + 31.0 * n + 31.0 * np.power(n, 2)) + * S3 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 32.0 + * (-4.0 - 1.0 * n + np.power(n, 2)) + * (2.0 + n + np.power(n, 2)) + * Sm2 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + + ( + 16.0 + * ( + 40.0 + + 132.0 * n + + 158.0 * np.power(n, 2) + + 155.0 * np.power(n, 3) + + 102.0 * np.power(n, 4) + + 37.0 * np.power(n, 5) + + 14.0 * np.power(n, 6) + + 2.0 * np.power(n, 7) + ) + * Sm2 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - (128.0 * (1.0 + n + np.power(n, 2)) * (2.0 + n + np.power(n, 2)) * Sm21) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 16.0 + * (2.0 + n + np.power(n, 2)) + * (10.0 + 7.0 * n + 7.0 * np.power(n, 2)) + * Sm3 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + -115.39746270332105 + - 2.6666666666666665 * np.power(S1, 3) + + 40.0 * S1 * S2 + - 32.0 * S21 + + 64.0 * S1 * Sm2 + + 16.0 * Sm3 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) + return a_Hq_l0 + a_Hq_l1 * L + a_Hq_l2 * L ** 2 + a_Hq_l3 * L ** 3 diff --git a/src/eko/matching_conditions/n3lo/agg.py b/src/eko/matching_conditions/n3lo/agg.py index 4a77918de..8b7fe5791 100644 --- a/src/eko/matching_conditions/n3lo/agg.py +++ b/src/eko/matching_conditions/n3lo/agg.py @@ -5,8 +5,8 @@ from .aggTF2 import A_ggTF2_3 -@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) -def A_gg_3(n, sx, smx, s3x, s4x, nf): +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4,f8)", cache=True) +def A_gg_3(n, sx, smx, s3x, s4x, nf, L): # pylint: disable=too-many-locals r""" Computes the |N3LO| singlet |OME| :math:`A_{gg}^{S,(3)}(N)`. The experssion is presented in :cite:`Bierenbaum:2009mv` @@ -24,7 +24,9 @@ def A_gg_3(n, sx, smx, s3x, s4x, nf): s4x : numpy.ndarray list S31, S221, Sm22, Sm211, Sm31 nf : int - numeber of active flavor below the threshold + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` Returns ------- @@ -40,7 +42,7 @@ def A_gg_3(n, sx, smx, s3x, s4x, nf): Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] S21, Sm21 = s3x[0], s3x[2] S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] - return ( + a_gg_l0 = ( -0.35616500834358344 + A_ggTF2_3(n, sx, s3x) + 0.75 @@ -765,3 +767,786 @@ def A_gg_3(n, sx, smx, s3x, s4x, nf): / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) ) ) + a_gg_l3 = ( + -0.2962962962962963 + + 0.3333333333333333 + * ( + (-8.88888888888889 * np.power(2.0 + n + np.power(n, 2), 2)) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - (7.111111111111111 * np.power(2.0 + n + np.power(n, 2), 2) * nf) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - 4.5 + * ( + (-13.037037037037036 * (1.0 + n + np.power(n, 2))) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + + 6.518518518518518 * S1 + ) + + 0.75 + * ( + (-16.59259259259259 * (1.0 + n + np.power(n, 2))) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + - 1.0 + * nf + * ( + (4.7407407407407405 * (1.0 + n + np.power(n, 2))) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + - 2.3703703703703702 * S1 + ) + + 8.296296296296296 * S1 + ) + - 2.0 + * ( + ( + -0.8888888888888888 + * np.power(2.0 + n + np.power(n, 2), 2) + * ( + -12.0 + - 34.0 * n + - 23.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - (5.333333333333333 * np.power(2.0 + n + np.power(n, 2), 2) * S1) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - 0.8888888888888888 + * ( + ( + -1.3333333333333333 + * np.power(2.0 + n + np.power(n, 2), 2) + * (2.0 + 3.0 * n + 3.0 * np.power(n, 2)) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + (5.333333333333333 * np.power(2.0 + n + np.power(n, 2), 2) * S1) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) + a_gg_l2 = ( + 0.75 + * ( + ( + 0.2962962962962963 + * ( + 96.0 + + 448.0 * n + + 626.0 * np.power(n, 2) + + 419.0 * np.power(n, 3) + + 367.0 * np.power(n, 4) + + 189.0 * np.power(n, 5) + + 63.0 * np.power(n, 6) + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - 23.703703703703702 * S1 + ) + + 0.3333333333333333 + * ( + ( + 0.8888888888888888 + * ( + -96.0 + - 224.0 * n + - 400.0 * np.power(n, 2) + - 546.0 * np.power(n, 3) + - 275.0 * np.power(n, 4) + - 18.0 * np.power(n, 5) + + 76.0 * np.power(n, 6) + + 60.0 * np.power(n, 7) + + 15.0 * np.power(n, 8) + ) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + (10.666666666666666 * np.power(2.0 + n + np.power(n, 2), 2) * S1) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 0.8888888888888888 + * ( + ( + -4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 + - 20.0 * n + - 26.0 * np.power(n, 2) + - 23.0 * np.power(n, 3) + + 7.0 * np.power(n, 4) + + 15.0 * np.power(n, 5) + + 7.0 * np.power(n, 6) + ) + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + + ( + 8.0 + * np.power(2.0 + n + np.power(n, 2), 2) + * (-2.0 + n + 5.0 * np.power(n, 2)) + * S1 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - (16.0 * np.power(2.0 + n + np.power(n, 2), 2) * S2) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 2.0 + * ( + ( + -0.2222222222222222 + * ( + -2304.0 + - 7104.0 * n + - 7232.0 * np.power(n, 2) + - 2496.0 * np.power(n, 3) + + 5240.0 * np.power(n, 4) + - 3624.0 * np.power(n, 5) + - 26198.0 * np.power(n, 6) + - 34351.0 * np.power(n, 7) + - 23124.0 * np.power(n, 8) + - 8809.0 * np.power(n, 9) + - 1366.0 * np.power(n, 10) + + 479.0 * np.power(n, 11) + + 264.0 * np.power(n, 12) + + 33.0 * np.power(n, 13) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 2.6666666666666665 + * ( + -48.0 + - 184.0 * n + - 24.0 * np.power(n, 2) + + 150.0 * np.power(n, 3) + + 255.0 * np.power(n, 4) + + 233.0 * np.power(n, 5) + + 91.0 * np.power(n, 6) + + 50.0 * np.power(n, 7) + + 35.0 * np.power(n, 8) + + 15.0 * np.power(n, 9) + + 3.0 * np.power(n, 10) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + (np.power(2.0 + n + np.power(n, 2), 2) * (-16.0 * S2 - 32.0 * Sm2)) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + + 4.5 + * ( + ( + -0.2222222222222222 + * ( + -768.0 + - 2688.0 * n + - 4256.0 * np.power(n, 2) + - 4632.0 * np.power(n, 3) + - 2060.0 * np.power(n, 4) + - 934.0 * np.power(n, 5) + - 2099.0 * np.power(n, 6) + - 2185.0 * np.power(n, 7) + - 1014.0 * np.power(n, 8) + - 124.0 * np.power(n, 9) + + 21.0 * np.power(n, 10) + + 3.0 * np.power(n, 11) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 3) + ) + - ( + 0.8888888888888888 + * ( + -96.0 + - 96.0 * n + + 428.0 * np.power(n, 2) + + 476.0 * np.power(n, 3) + + 79.0 * np.power(n, 4) + - 88.0 * np.power(n, 5) + + 46.0 * np.power(n, 6) + + 92.0 * np.power(n, 7) + + 23.0 * np.power(n, 8) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * np.power(2.0 + n, 2) + ) + + 21.333333333333332 * S1 * S2 + + 10.666666666666666 * S3 + + ( + (1.0 + n + np.power(n, 2)) + * (-42.666666666666664 * S2 - 42.666666666666664 * Sm2) + ) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + + 21.333333333333332 * S1 * Sm2 + - 21.333333333333332 * Sm21 + + 10.666666666666666 * Sm3 + ) + ) + a_gg_l1 = ( + 0.75 + * ( + ( + 0.07407407407407407 + * ( + 480.0 + + 1184.0 * n + - 256.0 * np.power(n, 2) + - 3762.0 * np.power(n, 3) + - 5931.0 * np.power(n, 4) + - 4554.0 * np.power(n, 5) + - 1440.0 * np.power(n, 6) + + 108.0 * np.power(n, 7) + + 27.0 * np.power(n, 8) + ) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + 0.8888888888888888 + * ( + -32.0 + - 70.0 * n + - 147.0 * np.power(n, 2) + - 132.0 * np.power(n, 3) + + 19.0 * np.power(n, 4) + + 114.0 * np.power(n, 5) + + 40.0 * np.power(n, 6) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - 1.0 + * nf + * ( + ( + -0.04938271604938271 + * ( + 864.0 + + 3360.0 * n + + 5008.0 * np.power(n, 2) + + 2874.0 * np.power(n, 3) + - 1193.0 * np.power(n, 4) + - 2094.0 * np.power(n, 5) + + 640.0 * np.power(n, 6) + + 1188.0 * np.power(n, 7) + + 297.0 * np.power(n, 8) + ) + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 0.19753086419753085 + * ( + -288.0 + - 630.0 * n + - 947.0 * np.power(n, 2) + - 552.0 * np.power(n, 3) + + 19.0 * np.power(n, 4) + + 390.0 * np.power(n, 5) + + 136.0 * np.power(n, 6) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) + + 0.3333333333333333 + * ( + ( + 0.2962962962962963 + * ( + -360.0 + - 1488.0 * n + - 3466.0 * np.power(n, 2) + - 4326.0 * np.power(n, 3) + - 3242.0 * np.power(n, 4) + - 2947.0 * np.power(n, 5) + - 2467.0 * np.power(n, 6) + - 82.0 * np.power(n, 7) + + 1640.0 * np.power(n, 8) + + 1095.0 * np.power(n, 9) + + 219.0 * np.power(n, 10) + ) + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + - ( + 3.5555555555555554 + * ( + -24.0 + - 56.0 * n + - 100.0 * np.power(n, 2) + - 129.0 * np.power(n, 3) + - 50.0 * np.power(n, 4) + + 3.0 * np.power(n, 5) + + 4.0 * np.power(n, 6) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + - 1.0 + * nf + * ( + ( + -0.4444444444444444 + * ( + -288.0 + - 1600.0 * n + - 4648.0 * np.power(n, 2) + - 7656.0 * np.power(n, 3) + - 8310.0 * np.power(n, 4) + - 6669.0 * np.power(n, 5) + - 3349.0 * np.power(n, 6) + - 762.0 * np.power(n, 7) + + 368.0 * np.power(n, 8) + + 335.0 * np.power(n, 9) + + 67.0 * np.power(n, 10) + ) + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + - ( + 10.666666666666666 + * ( + 16.0 + + 48.0 * n + + 90.0 * np.power(n, 2) + + 109.0 * np.power(n, 3) + + 52.0 * np.power(n, 4) + + 5.0 * np.power(n, 5) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * (16.0 * np.power(S1, 2) - 26.666666666666668 * S2) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - ( + 1.0 + * np.power(2.0 + n + np.power(n, 2), 2) + * (5.333333333333333 * np.power(S1, 2) - 16.0 * S2) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - 0.8888888888888888 + * ( + (-115.39746270332105 * (2.0 + n + np.power(n, 2))) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + - ( + 2.0 + * ( + 48.0 + + 152.0 * n + + 324.0 * np.power(n, 2) + + 490.0 * np.power(n, 3) + + 84.0 * np.power(n, 4) + - 786.0 * np.power(n, 5) + - 1057.0 * np.power(n, 6) + - 846.0 * np.power(n, 7) + - 379.0 * np.power(n, 8) + - 80.0 * np.power(n, 9) + - 5.0 * np.power(n, 10) + + 6.0 * np.power(n, 11) + + np.power(n, 12) + ) + ) + / ((-1.0 + n) * np.power(n, 5) * np.power(1.0 + n, 5) * (2.0 + n)) + - ( + 8.0 + * ( + -16.0 + - 32.0 * n + + 56.0 * np.power(n, 2) + + 158.0 * np.power(n, 3) + + 142.0 * np.power(n, 4) + + 95.0 * np.power(n, 5) + + 51.0 * np.power(n, 6) + + 23.0 * np.power(n, 7) + + 3.0 * np.power(n, 8) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * (2.0 + n)) + + ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * (6.0 + 9.0 * n + 4.0 * np.power(n, 2) + 5.0 * np.power(n, 3)) + * np.power(S1, 2) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 3) * (2.0 + n)) + - ( + 4.0 + * (2.0 + n + np.power(n, 2)) + * ( + -8.0 + + 10.0 * n + + 69.0 * np.power(n, 2) + + 48.0 * np.power(n, 3) + + 17.0 * np.power(n, 4) + ) + * S2 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * (-2.6666666666666665 * np.power(S1, 3) + 24.0 * S1 * S2 - 32.0 * S21) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 5.333333333333333 + * (2.0 + n + np.power(n, 2)) + * (-14.0 + 5.0 * n + 5.0 * np.power(n, 2)) + * S3 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 32.0 + * ( + -16.0 + - 24.0 * n + - 26.0 * np.power(n, 2) + - 3.0 * np.power(n, 3) + + np.power(n, 4) + + 3.0 * np.power(n, 5) + + np.power(n, 6) + ) + * Sm2 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * (2.0 + n)) + + ( + (2.0 + n + np.power(n, 2)) + * (-256.0 * S1 * Sm2 + 256.0 * Sm21 - 128.0 * Sm3) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - 2.0 + * ( + ( + -4.808227612638377 + * (10.0 + n + np.power(n, 2)) + * (18.0 + 5.0 * n + 5.0 * np.power(n, 2)) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 0.2962962962962963 + * ( + -12096.0 + - 47232.0 * n + - 79152.0 * np.power(n, 2) + - 82640.0 * np.power(n, 3) + - 33372.0 * np.power(n, 4) + + 43144.0 * np.power(n, 5) + + 28263.0 * np.power(n, 6) + - 83791.0 * np.power(n, 7) + - 204934.0 * np.power(n, 8) + - 246412.0 * np.power(n, 9) + - 171627.0 * np.power(n, 10) + - 50653.0 * np.power(n, 11) + + 22446.0 * np.power(n, 12) + + 30172.0 * np.power(n, 13) + + 13660.0 * np.power(n, 14) + + 3036.0 * np.power(n, 15) + + 276.0 * np.power(n, 16) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 5) + * np.power(1.0 + n, 5) + * np.power(2.0 + n, 4) + ) + + 76.93164180221403 * S1 + - ( + 0.8888888888888888 + * ( + 864.0 + + 2400.0 * n + + 3464.0 * np.power(n, 2) + + 2960.0 * np.power(n, 3) + - 1116.0 * np.power(n, 4) + - 6516.0 * np.power(n, 5) + - 5002.0 * np.power(n, 6) + - 2298.0 * np.power(n, 7) + - 1401.0 * np.power(n, 8) + - 452.0 * np.power(n, 9) + + 80.0 * np.power(n, 10) + + 90.0 * np.power(n, 11) + + 15.0 * np.power(n, 12) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 2) + ) + - ( + 1.3333333333333333 + * (2.0 + n + np.power(n, 2)) + * ( + -12.0 + - 16.0 * n + + 41.0 * np.power(n, 2) + - 6.0 * np.power(n, 3) + + 17.0 * np.power(n, 4) + ) + * np.power(S1, 2) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 2) + * (2.0 + n) + ) + - ( + 4.0 + * ( + 48.0 + + 80.0 * n + - 112.0 * np.power(n, 2) + - 204.0 * np.power(n, 3) + - 527.0 * np.power(n, 4) + - 454.0 * np.power(n, 5) + - 164.0 * np.power(n, 6) + - 14.0 * np.power(n, 7) + + 3.0 * np.power(n, 8) + ) + * S2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 5.333333333333333 + * (2.0 + n + np.power(n, 2)) + * (-26.0 + 5.0 * n + 5.0 * np.power(n, 2)) + * S3 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - ( + 32.0 + * (-4.0 - 1.0 * n + np.power(n, 2)) + * (2.0 + n + np.power(n, 2)) + * Sm2 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + - ( + 32.0 + * ( + -32.0 + - 12.0 * n + + 4.0 * np.power(n, 2) + + 81.0 * np.power(n, 3) + + 28.0 * np.power(n, 4) + + np.power(n, 5) + + 13.0 * np.power(n, 6) + + 10.0 * np.power(n, 7) + + 3.0 * np.power(n, 8) + ) + * Sm2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 64.0 + * ( + 16.0 + + 6.0 * n + + 7.0 * np.power(n, 2) + + 2.0 * np.power(n, 3) + + np.power(n, 4) + ) + * S1 + * Sm2 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - (32.0 * (2.0 + n + np.power(n, 2)) * (14.0 + n + np.power(n, 2)) * Sm21) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + np.power(2.0 + n + np.power(n, 2), 2) + * ( + -14.424682837915132 + + 2.6666666666666665 * np.power(S1, 3) + - 40.0 * S1 * S2 + + 32.0 * S21 + - 32.0 * S1 * Sm2 + - 16.0 * Sm3 + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + (96.0 * (2.0 + n + np.power(n, 2)) * (4.0 + n + np.power(n, 2)) * Sm3) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + - 4.5 + * ( + ( + 76.93164180221403 + * ( + 6.0 + + 5.0 * n + + 7.0 * np.power(n, 2) + + 4.0 * np.power(n, 3) + + 2.0 * np.power(n, 4) + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + ( + 0.012345679012345678 + * ( + 41472.0 + + 222336.0 * n + + 559488.0 * np.power(n, 2) + + 895648.0 * np.power(n, 3) + + 1.047352e6 * np.power(n, 4) + + 963340.0 * np.power(n, 5) + + 733338.0 * np.power(n, 6) + + 623697.0 * np.power(n, 7) + + 531516.0 * np.power(n, 8) + + 375431.0 * np.power(n, 9) + + 208394.0 * np.power(n, 10) + + 79295.0 * np.power(n, 11) + + 19944.0 * np.power(n, 12) + + 2493.0 * np.power(n, 13) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - 76.93164180221403 * S1 + - ( + 0.04938271604938271 + * ( + -3888.0 + - 12312.0 * n + - 33372.0 * np.power(n, 2) + - 40374.0 * np.power(n, 3) + + 14578.0 * np.power(n, 4) + + 113169.0 * np.power(n, 5) + + 140861.0 * np.power(n, 6) + + 93240.0 * np.power(n, 7) + + 44700.0 * np.power(n, 8) + + 17235.0 * np.power(n, 9) + + 5939.0 * np.power(n, 10) + + 2058.0 * np.power(n, 11) + + 310.0 * np.power(n, 12) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 2) + ) + + ( + 1.7777777777777777 + * ( + -24.0 + - 152.0 * n + - 274.0 * np.power(n, 2) + - 241.0 * np.power(n, 3) + - 113.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + ) + * S2 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + S1 * (71.11111111111111 * S2 - 10.666666666666666 * S3) + + ( + 0.8888888888888888 + * ( + 54.0 + + 33.0 * n + + 73.0 * np.power(n, 2) + + 80.0 * np.power(n, 3) + + 40.0 * np.power(n, 4) + ) + * S3 + ) + / (np.power(n, 2) * np.power(1.0 + n, 2)) + - ( + 1.7777777777777777 + * ( + 360.0 + + 108.0 * n + - 586.0 * np.power(n, 2) + - 1483.0 * np.power(n, 3) + - 848.0 * np.power(n, 4) + + 239.0 * np.power(n, 5) + + 691.0 * np.power(n, 6) + + 524.0 * np.power(n, 7) + + 131.0 * np.power(n, 8) + ) + * Sm2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 3.5555555555555554 + * ( + -108.0 + - 36.0 * n + - 85.0 * np.power(n, 2) + - 78.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + + 60.0 * np.power(n, 5) + + 20.0 * np.power(n, 6) + ) + * S1 + * Sm2 + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + 10.666666666666666 * np.power(Sm2, 2) + + ( + ( + -108.0 + - 72.0 * n + - 121.0 * np.power(n, 2) + - 78.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + + 60.0 * np.power(n, 5) + + 20.0 * np.power(n, 6) + ) + * (-3.5555555555555554 * Sm21 + 1.7777777777777777 * Sm3) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) + return a_gg_l0 + a_gg_l1 * L + a_gg_l2 * L ** 2 + a_gg_l3 * L ** 3 diff --git a/src/eko/matching_conditions/n3lo/agq.py b/src/eko/matching_conditions/n3lo/agq.py index 8b005a95e..cbfa642b5 100644 --- a/src/eko/matching_conditions/n3lo/agq.py +++ b/src/eko/matching_conditions/n3lo/agq.py @@ -3,8 +3,8 @@ import numpy as np -@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) -def A_gq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4,f8)", cache=True) +def A_gq_3(n, sx, smx, s3x, s4x, nf, L): # pylint: disable=too-many-locals r""" Computes the |N3LO| singlet |OME| :math:`A_{gq}^{S,(3)}(N)`. The experssion is presented in :cite:`Ablinger_2014` (eq 6.3) @@ -22,7 +22,9 @@ def A_gq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals s4x : numpy.ndarray list S31, S221, Sm22, Sm211, Sm31 nf : int - numeber of active flavor below the threshold + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` Returns ------- @@ -33,7 +35,7 @@ def A_gq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals Sm1, Sm2, Sm3, Sm4 = smx[0], smx[1], smx[2], smx[3] S21, S2m1, Sm21, Sm2m1 = s3x[0], s3x[1], s3x[2], s3x[3] S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] - return ( + a_gq_l0 = ( 0.3333333333333333 * ( ( @@ -625,3 +627,361 @@ def A_gq_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals / ((-1.0 + n) * n * (1.0 + n)) ) ) + a_gq_l3 = ( + -1.0 + * (2.0 + n + np.power(n, 2)) + * ( + 1.1851851851851851 * (2.0 + nf) + + 0.8888888888888888 + * ( + ( + 0.4444444444444444 + * ( + 48.0 + + 44.0 * n + + 52.0 * np.power(n, 2) + + 19.0 * np.power(n, 3) + + 17.0 * np.power(n, 4) + + 9.0 * np.power(n, 5) + + 3.0 * np.power(n, 6) + ) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + - 1.7777777777777777 * S1 + ) + + 2.0 + * ( + ( + -0.8888888888888888 + * ( + 4.0 + - 18.0 * n + - 7.0 * np.power(n, 2) + + 22.0 * np.power(n, 3) + + 11.0 * np.power(n, 4) + ) + ) + / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + + 1.7777777777777777 * S1 + ) + ) + ) / ((-1.0 + n) * n * (1.0 + n)) + a_gq_l2 = ( + 0.3333333333333333 + * ( + ( + 3.5555555555555554 + * (16.0 + 27.0 * n + 13.0 * np.power(n, 2) + 8.0 * np.power(n, 3)) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2)) + - (10.666666666666666 * (2.0 + n + np.power(n, 2)) * S1) + / ((-1.0 + n) * n * (1.0 + n)) + ) + + 0.8888888888888888 + * ( + ( + -0.2222222222222222 + * ( + -768.0 + + 112.0 * n + - 720.0 * np.power(n, 2) + - 1616.0 * np.power(n, 3) + - 3236.0 * np.power(n, 4) + - 2451.0 * np.power(n, 5) + - 526.0 * np.power(n, 6) + + 604.0 * np.power(n, 7) + + 450.0 * np.power(n, 8) + + 87.0 * np.power(n, 9) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 1.7777777777777777 + * (-6.0 + 17.0 * n + 4.0 * np.power(n, 2) + 7.0 * np.power(n, 3)) + * S1 + ) + / ((-1.0 + n) * np.power(n, 2) * (1.0 + n)) + + ( + 2.6666666666666665 + * (2.0 + n + np.power(n, 2)) + * (np.power(S1, 2) - 5.0 * S2) + ) + / ((-1.0 + n) * n * (1.0 + n)) + ) + + 2.0 + * ( + ( + 0.4444444444444444 + * ( + 384.0 + + 896.0 * n + + 528.0 * np.power(n, 2) + - 124.0 * np.power(n, 3) + - 820.0 * np.power(n, 4) + - 309.0 * np.power(n, 5) + + 694.0 * np.power(n, 6) + + 860.0 * np.power(n, 7) + + 414.0 * np.power(n, 8) + + 69.0 * np.power(n, 9) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 3.5555555555555554 + * ( + 30.0 + - 7.0 * n + - 33.0 * np.power(n, 2) + - 8.0 * np.power(n, 3) + - 1.0 * np.power(n, 4) + + np.power(n, 5) + ) + * S1 + ) + / (np.power(-1.0 + n, 2) * np.power(n, 2) * (1.0 + n) * (2.0 + n)) + + ( + (2.0 + n + np.power(n, 2)) + * (-2.6666666666666665 * np.power(S1, 2) - 8.0 * S2 - 16.0 * Sm2) + ) + / ((-1.0 + n) * n * (1.0 + n)) + ) + ) + a_gq_l1 = ( + (-12.246913580246913 * (2.0 + n + np.power(n, 2))) + / ((-1.0 + n) * n * (1.0 + n)) + - 0.3333333333333333 + * nf + * ( + ( + 1.1851851851851851 + * ( + 38.0 + + 80.0 * n + + 86.0 * np.power(n, 2) + + 81.0 * np.power(n, 3) + + 19.0 * np.power(n, 4) + ) + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 3)) + + ( + 3.5555555555555554 + * (16.0 + 27.0 * n + 13.0 * np.power(n, 2) + 8.0 * np.power(n, 3)) + * S1 + ) + / ((-1.0 + n) * n * np.power(1.0 + n, 2)) + + ( + (2.0 + n + np.power(n, 2)) + * (-5.333333333333333 * np.power(S1, 2) - 5.333333333333333 * S2) + ) + / ((-1.0 + n) * n * (1.0 + n)) + ) + - 0.8888888888888888 + * ( + ( + -0.07407407407407407 + * ( + 3456.0 + + 9504.0 * n + + 18240.0 * np.power(n, 2) + + 65344.0 * np.power(n, 3) + + 81160.0 * np.power(n, 4) + + 44386.0 * np.power(n, 5) + + 3704.0 * np.power(n, 6) + - 32981.0 * np.power(n, 7) + - 31663.0 * np.power(n, 8) + - 11406.0 * np.power(n, 9) + + 436.0 * np.power(n, 10) + + 1545.0 * np.power(n, 11) + + 339.0 * np.power(n, 12) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 5) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 2) + ) + + ( + 0.2962962962962963 + * ( + -72.0 + - 408.0 * n + - 446.0 * np.power(n, 2) + + 175.0 * np.power(n, 3) + + 472.0 * np.power(n, 4) + + 243.0 * np.power(n, 5) + + 164.0 * np.power(n, 6) + ) + * S1 + ) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3)) + - ( + 0.4444444444444444 + * ( + -24.0 + + 74.0 * n + + 135.0 * np.power(n, 2) + + 68.0 * np.power(n, 3) + + 43.0 * np.power(n, 4) + ) + * np.power(S1, 2) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2)) + - ( + 0.4444444444444444 + * ( + -288.0 + - 480.0 * n + - 1444.0 * np.power(n, 2) + - 2036.0 * np.power(n, 3) + - 807.0 * np.power(n, 4) + + 802.0 * np.power(n, 5) + + 1056.0 * np.power(n, 6) + + 706.0 * np.power(n, 7) + + 187.0 * np.power(n, 8) + ) + * S2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * (2.0 + n) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + -76.93164180221403 + - 0.8888888888888888 * np.power(S1, 3) + + 29.333333333333332 * S1 * S2 + - 10.666666666666666 * S21 + + 19.555555555555557 * S3 + - (128.0 * Sm2) / ((-1.0 + n) * n * (1.0 + n) * (2.0 + n)) + ) + ) + / ((-1.0 + n) * n * (1.0 + n)) + ) + - 2.0 + * ( + ( + 0.2962962962962963 + * ( + 288.0 + + 7440.0 * n + + 28928.0 * np.power(n, 2) + + 49136.0 * np.power(n, 3) + + 44966.0 * np.power(n, 4) + + 23063.0 * np.power(n, 5) + + 5814.0 * np.power(n, 6) + + 8033.0 * np.power(n, 7) + + 14891.0 * np.power(n, 8) + + 13239.0 * np.power(n, 9) + + 7232.0 * np.power(n, 10) + + 2301.0 * np.power(n, 11) + + 301.0 * np.power(n, 12) + ) + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 0.2962962962962963 + * ( + 576.0 + - 1680.0 * n + - 8464.0 * np.power(n, 2) + - 7168.0 * np.power(n, 3) + + 4460.0 * np.power(n, 4) + + 11533.0 * np.power(n, 5) + + 9317.0 * np.power(n, 6) + + 5347.0 * np.power(n, 7) + + 2139.0 * np.power(n, 8) + + 356.0 * np.power(n, 9) + ) + * S1 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + ( + 0.4444444444444444 + * ( + -264.0 + - 88.0 * n + + 324.0 * np.power(n, 2) + + 127.0 * np.power(n, 3) + + 86.0 * np.power(n, 4) + + 31.0 * np.power(n, 5) + ) + * np.power(S1, 2) + ) + / (np.power(-1.0 + n, 2) * np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - ( + 1.3333333333333333 + * ( + 56.0 + - 92.0 * np.power(n, 2) + - 1.0 * np.power(n, 3) + + 37.0 * np.power(n, 4) + + 33.0 * np.power(n, 5) + + 15.0 * np.power(n, 6) + ) + * S2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * (2.0 + n) + ) + - ( + 5.333333333333333 + * ( + -40.0 + - 72.0 * n + - 76.0 * np.power(n, 2) + + 39.0 * np.power(n, 3) + + 51.0 * np.power(n, 4) + + 37.0 * np.power(n, 5) + + 13.0 * np.power(n, 6) + ) + * Sm2 + ) + / ( + np.power(-1.0 + n, 2) + * np.power(n, 2) + * np.power(1.0 + n, 2) + * (2.0 + n) + ) + + ( + (2.0 + n + np.power(n, 2)) + * ( + 76.93164180221403 + + 0.8888888888888888 * np.power(S1, 3) + + 18.666666666666668 * S1 * S2 + + 28.444444444444443 * S3 + + 42.666666666666664 * S1 * Sm2 + - 21.333333333333332 * Sm21 + + 21.333333333333332 * Sm3 + ) + ) + / ((-1.0 + n) * n * (1.0 + n)) + ) + ) + return a_gq_l0 + a_gq_l1 * L + a_gq_l2 * L ** 2 + a_gq_l3 * L ** 3 diff --git a/src/eko/matching_conditions/n3lo/aqg.py b/src/eko/matching_conditions/n3lo/aqg.py index 945967d05..f8a9949a1 100644 --- a/src/eko/matching_conditions/n3lo/aqg.py +++ b/src/eko/matching_conditions/n3lo/aqg.py @@ -3,8 +3,8 @@ import numpy as np -@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) -def A_qg_3(n, sx, smx, s3x, s4x, nf): +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4,f8)", cache=True) +def A_qg_3(n, sx, smx, s3x, s4x, nf, L): r""" Computes the |N3LO| singlet |OME| :math:`A_{qg}^{S,(3)}(N)`. The expression is presented in :cite:`Bierenbaum:2009mv` @@ -22,7 +22,9 @@ def A_qg_3(n, sx, smx, s3x, s4x, nf): s4x : numpy.ndarray list S31, S221, Sm22, Sm211, Sm31 nf : int - numeber of active flavor below the threshold + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` Returns ------- @@ -33,7 +35,7 @@ def A_qg_3(n, sx, smx, s3x, s4x, nf): Sm2, Sm3, Sm4 = smx[1], smx[2], smx[3] S21 = s3x[0] S31, S211 = s4x[0], s4x[1] - return 0.3333333333333333 * nf * ( + a_qg_l0 = 0.3333333333333333 * nf * ( ( -8.547960200246003 * (2.0 + n + np.power(n, 2)) @@ -256,3 +258,222 @@ def A_qg_3(n, sx, smx, s3x, s4x, nf): ) / (n * (1.0 + n) * (2.0 + n)) ) + a_qg_l3 = ( + (29.62962962962963 * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + + (14.222222222222221 * nf) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + + (23.703703703703702 * nf) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + + (37.925925925925924 * nf) + / ((-1.0 + n) * n * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + + (16.88888888888889 * n * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + - (4.148148148148148 * np.power(n, 3) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + - (3.5555555555555554 * np.power(n, 4) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + - (0.8888888888888888 * np.power(n, 5) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 2)) + + (21.333333333333332 * nf) + / ((-1.0 + n) * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (10.666666666666666 * nf) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (16.0 * nf) / ((-1.0 + n) * n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (10.666666666666666 * n * nf) + / ((-1.0 + n) * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (5.333333333333333 * np.power(n, 2) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - (1.4814814814814814 * nf * S1) / ((1.0 + n) * (2.0 + n)) + - (2.962962962962963 * nf * S1) / (n * (1.0 + n) * (2.0 + n)) + - (1.4814814814814814 * n * nf * S1) / ((1.0 + n) * (2.0 + n)) + ) + a_qg_l2 = ( + (754.9629629629629 * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + (170.66666666666666 * nf) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + (512.0 * nf) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + (808.2962962962963 * nf) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + (1085.6296296296296 * nf) + / ((-1.0 + n) * n * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + (331.25925925925924 * n * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + (216.74074074074073 * np.power(n, 2) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + (224.14814814814815 * np.power(n, 3) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + (191.11111111111111 * np.power(n, 4) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + (103.4074074074074 * np.power(n, 5) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + (34.22222222222222 * np.power(n, 6) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + + (4.888888888888889 * np.power(n, 7) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 3)) + - (674.6666666666666 * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - (106.66666666666667 * nf) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - (448.0 * nf) / ((-1.0 + n) * n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - (746.6666666666666 * n * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - (478.0 * np.power(n, 2) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - (121.33333333333333 * np.power(n, 3) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + (37.333333333333336 * np.power(n, 4) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + (36.0 * np.power(n, 5) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + (6.0 * np.power(n, 6) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + (154.66666666666666 * nf * S1) / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (53.333333333333336 * nf * S1) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (125.33333333333333 * n * nf * S1) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (53.333333333333336 * np.power(n, 2) * nf * S1) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (13.333333333333334 * np.power(n, 3) * nf * S1) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - (9.481481481481481 * nf * S1) / ((1.0 + n) * (2.0 + n)) + - (7.111111111111111 * nf * S1) / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - (22.51851851851852 * nf * S1) / (n * (1.0 + n) * (2.0 + n)) + - (5.925925925925926 * n * nf * S1) / ((1.0 + n) * (2.0 + n)) + - (2.2222222222222223 * nf * np.power(S1, 2)) / ((1.0 + n) * (2.0 + n)) + - (4.444444444444445 * nf * np.power(S1, 2)) / (n * (1.0 + n) * (2.0 + n)) + - (2.2222222222222223 * n * nf * np.power(S1, 2)) / ((1.0 + n) * (2.0 + n)) + - (2.2222222222222223 * nf * S2) / ((1.0 + n) * (2.0 + n)) + - (4.444444444444445 * nf * S2) / (n * (1.0 + n) * (2.0 + n)) + - (2.2222222222222223 * n * nf * S2) / ((1.0 + n) * (2.0 + n)) + - (8.0 * nf * Sm2) / ((1.0 + n) * (2.0 + n)) + - (16.0 * nf * Sm2) / (n * (1.0 + n) * (2.0 + n)) + - (8.0 * n * nf * Sm2) / ((1.0 + n) * (2.0 + n)) + ) + a_qg_l1 = ( + (7208.2962962962965 * nf) + / ((-1.0 + n) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + + (853.3333333333334 * nf) + / ((-1.0 + n) * np.power(n, 5) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + + (3640.8888888888887 * nf) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + + (7808.0 * nf) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + + (11938.765432098766 * nf) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + + (12726.913580246914 * nf) + / ((-1.0 + n) * n * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + + (1396.8395061728395 * n * nf) + / ((-1.0 + n) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + - (1495.4074074074074 * np.power(n, 2) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + - (3089.037037037037 * np.power(n, 3) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + - (3217.8765432098767 * np.power(n, 4) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + - (2158.1728395061727 * np.power(n, 5) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + - (1036.148148148148 * np.power(n, 6) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + - (356.69135802469134 * np.power(n, 7) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + - (78.51851851851852 * np.power(n, 8) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + - (7.851851851851852 * np.power(n, 9) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 5) * np.power(2.0 + n, 4)) + + (5069.333333333333 * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + - (384.0 * nf) + / ((-1.0 + n) * np.power(n, 4) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + - (1856.0 * nf) + / ((-1.0 + n) * np.power(n, 3) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + - (3363.5555555555557 * nf) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + - (1706.6666666666667 * nf) + / ((-1.0 + n) * n * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + + (12603.111111111111 * n * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + + (14692.888888888889 * np.power(n, 2) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + + (9295.111111111111 * np.power(n, 3) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + + (1911.111111111111 * np.power(n, 4) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + - (1507.5555555555557 * np.power(n, 5) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + - (1289.7777777777778 * np.power(n, 6) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + - (396.0 * np.power(n, 7) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + - (44.0 * np.power(n, 8) * nf) + / ((-1.0 + n) * np.power(1.0 + n, 4) * np.power(2.0 + n, 4)) + - (1249.7777777777778 * nf * S1) / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - (302.22222222222223 * nf * S1) + / (n * np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - (2168.0 * n * nf * S1) / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - (1885.7777777777778 * np.power(n, 2) * nf * S1) + / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - (936.0 * np.power(n, 3) * nf * S1) + / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - (280.44444444444446 * np.power(n, 4) * nf * S1) + / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + - (41.77777777777778 * np.power(n, 5) * nf * S1) + / (np.power(1.0 + n, 3) * np.power(2.0 + n, 3)) + + (117.33333333333333 * nf * S1) / (np.power(1.0 + n, 2) * (2.0 + n)) + + (23.703703703703702 * nf * S1) + / (np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + + (103.50617283950618 * nf * S1) / (n * np.power(1.0 + n, 2) * (2.0 + n)) + + (50.76543209876543 * n * nf * S1) / (np.power(1.0 + n, 2) * (2.0 + n)) + + (20.34567901234568 * np.power(n, 2) * nf * S1) + / (np.power(1.0 + n, 2) * (2.0 + n)) + + (130.66666666666666 * nf * np.power(S1, 2)) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (53.333333333333336 * nf * np.power(S1, 2)) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (109.33333333333333 * n * nf * np.power(S1, 2)) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (53.333333333333336 * np.power(n, 2) * nf * np.power(S1, 2)) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (13.333333333333334 * np.power(n, 3) * nf * np.power(S1, 2)) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - (7.703703703703703 * nf * np.power(S1, 2)) / ((1.0 + n) * (2.0 + n)) + - (3.5555555555555554 * nf * np.power(S1, 2)) + / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - (17.185185185185187 * nf * np.power(S1, 2)) / (n * (1.0 + n) * (2.0 + n)) + - (5.925925925925926 * n * nf * np.power(S1, 2)) / ((1.0 + n) * (2.0 + n)) + - (0.7407407407407407 * nf * np.power(S1, 3)) / ((1.0 + n) * (2.0 + n)) + - (1.4814814814814814 * nf * np.power(S1, 3)) / (n * (1.0 + n) * (2.0 + n)) + - (0.7407407407407407 * n * nf * np.power(S1, 3)) / ((1.0 + n) * (2.0 + n)) + + (114.66666666666667 * nf * S2) / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (53.333333333333336 * nf * S2) + / (n * np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (125.33333333333333 * n * nf * S2) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (69.33333333333333 * np.power(n, 2) * nf * S2) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + + (13.333333333333334 * np.power(n, 3) * nf * S2) + / (np.power(1.0 + n, 2) * np.power(2.0 + n, 2)) + - (14.814814814814815 * nf * S2) / ((1.0 + n) * (2.0 + n)) + - (3.5555555555555554 * nf * S2) / (np.power(n, 2) * (1.0 + n) * (2.0 + n)) + - (17.185185185185187 * nf * S2) / (n * (1.0 + n) * (2.0 + n)) + - (5.925925925925926 * n * nf * S2) / ((1.0 + n) * (2.0 + n)) + + (5.777777777777778 * nf * S1 * S2) / ((1.0 + n) * (2.0 + n)) + + (11.555555555555555 * nf * S1 * S2) / (n * (1.0 + n) * (2.0 + n)) + + (5.777777777777778 * n * nf * S1 * S2) / ((1.0 + n) * (2.0 + n)) + - (16.0 * nf * S21) / ((1.0 + n) * (2.0 + n)) + - (32.0 * nf * S21) / (n * (1.0 + n) * (2.0 + n)) + - (16.0 * n * nf * S21) / ((1.0 + n) * (2.0 + n)) + - (5.037037037037037 * nf * S3) / ((1.0 + n) * (2.0 + n)) + - (10.074074074074074 * nf * S3) / (n * (1.0 + n) * (2.0 + n)) + - (5.037037037037037 * n * nf * S3) / ((1.0 + n) * (2.0 + n)) + + (42.666666666666664 * nf * Sm2) / ((1.0 + n) * (2.0 + n)) + + (53.333333333333336 * nf * Sm2) / (n * (1.0 + n) * (2.0 + n)) + + (26.666666666666668 * n * nf * Sm2) / ((1.0 + n) * (2.0 + n)) + - (16.0 * nf * Sm3) / ((1.0 + n) * (2.0 + n)) + - (32.0 * nf * Sm3) / (n * (1.0 + n) * (2.0 + n)) + - (16.0 * n * nf * Sm3) / ((1.0 + n) * (2.0 + n)) + ) + return a_qg_l0 + a_qg_l1 * L + a_qg_l2 * L ** 2 + a_qg_l3 * L ** 3 diff --git a/src/eko/matching_conditions/n3lo/aqqNS.py b/src/eko/matching_conditions/n3lo/aqqNS.py index d42176d46..ff04a94c5 100644 --- a/src/eko/matching_conditions/n3lo/aqqNS.py +++ b/src/eko/matching_conditions/n3lo/aqqNS.py @@ -5,8 +5,8 @@ from . import s_functions as sf -@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4)", cache=True) -def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals +@nb.njit("c16(c16,c16[:],c16[:],c16[:],c16[:],u4,f8)", cache=True) +def A_qqNS_3(n, sx, smx, s3x, s4x, nf, L): # pylint: disable=too-many-locals r""" Computes the |N3LO| singlet |OME| :math:`A_{qq}^{NS,(3)}(N)`. The experssion is presented in :cite:`Bierenbaum:2009mv` and @@ -26,7 +26,9 @@ def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals s4x : numpy.ndarray list S31, S221, Sm22, Sm211, Sm31 nf : int - numeber of active flavor below the threshold + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` Returns ------- @@ -47,7 +49,7 @@ def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals S23 = sf.harmonic_S23(n, S1, S2, S3) Sm23 = sf.harmonic_Sm23(n, Sm1, Sm2, Sm3) S2m3 = sf.harmonic_S2m3(n, S2, Sm1, Sm2, Sm3) - return ( + a_qqNS_l0 = ( 0.3333333333333333 * nf * ( @@ -650,3 +652,106 @@ def A_qqNS_3(n, sx, smx, s3x, s4x, nf): # pylint: disable=too-many-locals + 28.444444444444443 * Sm5 ) ) + a_qqNS_l3 = ( + 8.592592592592593 / (1.0 + n) + + 5.728395061728395 / (n * (1.0 + n)) + + (8.592592592592593 * n) / (1.0 + n) + - (0.5925925925925926 * nf) / (1.0 + n) + - (0.3950617283950617 * nf) / (n * (1.0 + n)) + - (0.5925925925925926 * n * nf) / (1.0 + n) + - 11.45679012345679 * S1 + + 0.7901234567901234 * nf * S1 + ) + a_qqNS_l2 = ( + 113.33333333333333 / np.power(1.0 + n, 3) + + 7.111111111111111 / (np.power(n, 3) * np.power(1.0 + n, 3)) + + 23.703703703703702 / (np.power(n, 2) * np.power(1.0 + n, 3)) + + 63.111111111111114 / (n * np.power(1.0 + n, 3)) + + (124.0 * n) / np.power(1.0 + n, 3) + + (89.33333333333333 * np.power(n, 2)) / np.power(1.0 + n, 3) + + (29.77777777777778 * np.power(n, 3)) / np.power(1.0 + n, 3) + + 4.6419753086419755 / np.power(1.0 + n, 2) + - 1.1851851851851851 / (np.power(n, 2) * np.power(1.0 + n, 2)) + + 1.9753086419753085 / (n * np.power(1.0 + n, 2)) + + (0.5925925925925926 * n) / np.power(1.0 + n, 2) + + (0.2962962962962963 * np.power(n, 2)) / np.power(1.0 + n, 2) + - 44.839506172839506 * S1 + - (7.111111111111111 * S1) / np.power(1.0 + n, 2) + - (9.481481481481481 * S1) / (np.power(n, 2) * np.power(1.0 + n, 2)) + - (18.962962962962962 * S1) / (n * np.power(1.0 + n, 2)) + - (14.222222222222221 * n * S1) / np.power(1.0 + n, 2) + - (7.111111111111111 * np.power(n, 2) * S1) / np.power(1.0 + n, 2) + + 2.3703703703703702 * S2 + - (14.222222222222221 * S2) / (1.0 + n) + - (9.481481481481481 * S2) / (n * (1.0 + n)) + - (14.222222222222221 * n * S2) / (1.0 + n) + + 18.962962962962962 * S1 * S2 + - 2.3703703703703702 * S3 + + (2.3703703703703702 * Sm2) / (n * (1.0 + n)) + - 4.7407407407407405 * S1 * Sm2 + + 4.7407407407407405 * Sm21 + - 2.3703703703703702 * Sm3 + ) + a_qqNS_l1 = ( + -211.92592592592592 / np.power(1.0 + n, 4) + + 18.962962962962962 / (np.power(n, 4) * np.power(1.0 + n, 4)) + + 16.0 / (np.power(n, 3) * np.power(1.0 + n, 4)) + + 24.098765432098766 / (np.power(n, 2) * np.power(1.0 + n, 4)) + + 18.864197530864196 / (n * np.power(1.0 + n, 4)) + - (115.55555555555556 * n) / np.power(1.0 + n, 4) + + (444.69135802469134 * np.power(n, 2)) / np.power(1.0 + n, 4) + + (469.037037037037 * np.power(n, 3)) / np.power(1.0 + n, 4) + + (117.25925925925925 * np.power(n, 4)) / np.power(1.0 + n, 4) + - 70.23315829196848 / (1.0 + n) + - 46.82210552797899 / (n * (1.0 + n)) + - (70.23315829196848 * n) / (1.0 + n) + - (16.016460905349795 * nf) / np.power(1.0 + n, 3) + + (1.1851851851851851 * nf) / (np.power(n, 3) * np.power(1.0 + n, 3)) + - (0.7901234567901234 * nf) / (np.power(n, 2) * np.power(1.0 + n, 3)) + - (8.823045267489713 * nf) / (n * np.power(1.0 + n, 3)) + - (25.267489711934157 * n * nf) / np.power(1.0 + n, 3) + - (25.925925925925927 * np.power(n, 2) * nf) / np.power(1.0 + n, 3) + - (8.641975308641975 * np.power(n, 3) * nf) / np.power(1.0 + n, 3) + + 93.64421105595798 * S1 + + (143.60493827160494 * S1) / np.power(1.0 + n, 3) + - (27.25925925925926 * S1) / (np.power(n, 3) * np.power(1.0 + n, 3)) + - (22.91358024691358 * S1) / (np.power(n, 2) * np.power(1.0 + n, 3)) + + (78.22222222222223 * S1) / (n * np.power(1.0 + n, 3)) + + (127.4074074074074 * n * S1) / np.power(1.0 + n, 3) + + (127.4074074074074 * np.power(n, 2) * S1) / np.power(1.0 + n, 3) + + (42.46913580246913 * np.power(n, 3) * S1) / np.power(1.0 + n, 3) + + 8.954732510288066 * nf * S1 + - 132.74074074074073 * S2 + + (62.41975308641975 * S2) / np.power(1.0 + n, 2) + - (18.962962962962962 * S2) / (np.power(n, 2) * np.power(1.0 + n, 2)) + + (12.641975308641975 * S2) / (n * np.power(1.0 + n, 2)) + + (23.703703703703702 * n * S2) / np.power(1.0 + n, 2) + + (11.851851851851851 * np.power(n, 2) * S2) / np.power(1.0 + n, 2) + + 3.950617283950617 * nf * S2 + - 63.20987654320987 * S1 * S2 + + 18.962962962962962 * np.power(S2, 2) + + (18.567901234567902 * S3) / (1.0 + n) + - (5.925925925925926 * S3) / (n * (1.0 + n)) + + (18.567901234567902 * n * S3) / (1.0 + n) + - 2.3703703703703702 * nf * S3 + + 11.851851851851851 * S1 * S3 + + 47.407407407407405 * S31 + - 30.814814814814813 * S4 + - (12.641975308641975 * Sm2) / np.power(1.0 + n, 2) + + (2.3703703703703702 * Sm2) / (np.power(n, 2) * np.power(1.0 + n, 2)) + - (7.901234567901234 * Sm2) / (n * np.power(1.0 + n, 2)) + + 15.802469135802468 * S1 * Sm2 + - 4.7407407407407405 * S2 * Sm2 + - (15.802469135802468 * Sm21) / (1.0 + n) + + (4.7407407407407405 * Sm21) / (n * (1.0 + n)) + - (15.802469135802468 * n * Sm21) / (1.0 + n) + - 9.481481481481481 * S1 * Sm21 + + 18.962962962962962 * Sm211 + - 4.7407407407407405 * Sm22 + + (7.901234567901234 * Sm3) / (1.0 + n) + + (2.3703703703703702 * Sm3) / (n * (1.0 + n)) + + (7.901234567901234 * n * Sm3) / (1.0 + n) + - 4.7407407407407405 * S1 * Sm3 + - 4.7407407407407405 * Sm4 + ) + return a_qqNS_l0 + a_qqNS_l1 * L + a_qqNS_l2 * L ** 2 + a_qqNS_l3 * L ** 3 diff --git a/src/eko/matching_conditions/n3lo/aqqPS.py b/src/eko/matching_conditions/n3lo/aqqPS.py index 1131365ab..f138b804e 100644 --- a/src/eko/matching_conditions/n3lo/aqqPS.py +++ b/src/eko/matching_conditions/n3lo/aqqPS.py @@ -3,8 +3,8 @@ import numpy as np -@nb.njit("c16(c16,c16[:],u4)", cache=True) -def A_qqPS_3(n, sx, nf): +@nb.njit("c16(c16,c16[:],u4,f8)", cache=True) +def A_qqPS_3(n, sx, nf, L): r""" Computes the |N3LO| singlet |OME| :math:`A_{qq}^{PS,(3)}(N)`. The expression is presented in :cite:`Bierenbaum:2009mv` @@ -16,7 +16,9 @@ def A_qqPS_3(n, sx, nf): sx : numpy.ndarray list S1 ... S5 nf : int - numeber of active flavor below the threshold + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` Returns ------- @@ -24,7 +26,7 @@ def A_qqPS_3(n, sx, nf): :math:`A_{qq}^{PS,(3)}(N)` """ S1, S2, S3 = sx[0], sx[1], sx[2] - return ( + a_qqPS_l0 = ( 0.3333333333333333 * nf * ( @@ -107,3 +109,88 @@ def A_qqPS_3(n, sx, nf): / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) ) ) + a_qqPS_l3 = (1.1851851851851851 * np.power(2.0 + n + np.power(n, 2), 2) * nf) / ( + (-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n) + ) + a_qqPS_l2 = ( + 0.3333333333333333 + * nf + * ( + ( + -3.5555555555555554 + * ( + -24.0 + - 20.0 * n + + 58.0 * np.power(n, 2) + + 61.0 * np.power(n, 3) + + 85.0 * np.power(n, 4) + + 83.0 * np.power(n, 5) + + 37.0 * np.power(n, 6) + + 8.0 * np.power(n, 7) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + + (10.666666666666666 * np.power(2.0 + n + np.power(n, 2), 2) * S1) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) + a_qqPS_l1 = ( + 0.3333333333333333 + * nf + * ( + ( + 1.1851851851851851 + * ( + 144.0 + - 48.0 * n + - 808.0 * np.power(n, 2) + + 200.0 * np.power(n, 3) + + 3309.0 * np.power(n, 4) + + 4569.0 * np.power(n, 5) + + 4763.0 * np.power(n, 6) + + 4269.0 * np.power(n, 7) + + 2379.0 * np.power(n, 8) + + 712.0 * np.power(n, 9) + + 95.0 * np.power(n, 10) + ) + ) + / ( + (-1.0 + n) + * np.power(n, 4) + * np.power(1.0 + n, 4) + * np.power(2.0 + n, 3) + ) + - ( + 7.111111111111111 + * ( + -24.0 + - 20.0 * n + + 58.0 * np.power(n, 2) + + 61.0 * np.power(n, 3) + + 85.0 * np.power(n, 4) + + 83.0 * np.power(n, 5) + + 37.0 * np.power(n, 6) + + 8.0 * np.power(n, 7) + ) + * S1 + ) + / ( + (-1.0 + n) + * np.power(n, 3) + * np.power(1.0 + n, 3) + * np.power(2.0 + n, 2) + ) + - ( + 1.0 + * np.power(2.0 + n + np.power(n, 2), 2) + * (-10.666666666666666 * np.power(S1, 2) - 10.666666666666666 * S2) + ) + / ((-1.0 + n) * np.power(n, 2) * np.power(1.0 + n, 2) * (2.0 + n)) + ) + ) + return a_qqPS_l0 + a_qqPS_l1 * L + a_qqPS_l2 * L ** 2 + a_qqPS_l3 * L ** 3 diff --git a/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index 2726dda40..35bb420e5 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -104,7 +104,7 @@ def A_singlet(order, n, sx, nf, L): if order >= 2: A_singlet[1] = nnlo.A_singlet_2(n, sx, L) if order >= 3: - A_singlet[2] = n3lo.A_singlet_3(n, sx, nf) + A_singlet[2] = n3lo.A_singlet_3(n, sx, nf, L) return A_singlet @@ -144,7 +144,7 @@ def A_non_singlet(order, n, sx, nf, L): if order >= 2: A_ns[1] = nnlo.A_ns_2(n, sx, L) if order >= 3: - A_ns[2] = n3lo.A_ns_3(n, sx, nf) + A_ns[2] = n3lo.A_ns_3(n, sx, nf, L) return A_ns @@ -162,7 +162,7 @@ def build_ome(A, order, a_s, backward_method): a_s : float strong coupling, needed only for the exact inverse backward_method : ["exact", "expanded" or ""] - empty or method for inverting the matching contidtion (exact or expanded) + empty or method for inverting the matching condition (exact or expanded) Returns ------- @@ -226,7 +226,7 @@ def quad_ker(u, order, mode, is_log, logx, areas, a_s, nf, L, backward_method): L : float :math:`log(q^2/m_h^2)` backward_method : ["exact", "expanded" or ""] - empty or method for inverting the matching contidtion (exact or expanded) + empty or method for inverting the matching condition (exact or expanded) Returns ------- ker : float diff --git a/tests/test_matching_n3lo.py b/tests/test_matching_n3lo.py index 62c0629ba..29c2e817c 100644 --- a/tests/test_matching_n3lo.py +++ b/tests/test_matching_n3lo.py @@ -24,42 +24,44 @@ def get_sx(N): def test_A_3(): + logs = [0, 10] nf = 3 - N = 1.0 - sx = get_sx(N) - smx = get_smx(N) - s3x = get_s3x(N, sx, smx) - s4x = get_s4x(N, sx, smx) - - aNSqq3 = A_qqNS_3(N, sx, smx, s3x, s4x, nf) - # quark number conservation - # the accuracy of this test depends directly on the precision of the - # F functions, thus is dominated by F19,F20,F21 accuracy are the worst ones - # If needed, these Fs can be improved. - np.testing.assert_allclose(aNSqq3, 0.0, atol=5e-3) - - N = 2.0 - sx = get_sx(N) - smx = get_smx(N) - s3x = get_s3x(N, sx, smx) - s4x = get_s4x(N, sx, smx) - # reference value comes form Mathemtica, gg is not fullycomplete - # thus the reference value is not 0.0 - # Here the acuracy of this test depends on the approximation of AggTF2 - np.testing.assert_allclose( - n3lo.A_gg_3(N, sx, smx, s3x, s4x, nf) - + n3lo.A_qg_3(N, sx, smx, s3x, s4x, nf) - + n3lo.A_Hg_3(N, sx, smx, s3x, s4x, nf), - 145.148, - rtol=32e-3, - ) + + for L in logs: + N = 1.0 + sx = get_sx(N) + smx = get_smx(N) + s3x = get_s3x(N, sx, smx) + s4x = get_s4x(N, sx, smx) + aNSqq3 = A_qqNS_3(N, sx, smx, s3x, s4x, nf, L) + # quark number conservation + # the accuracy of this test depends directly on the precision of the + # F functions, thus is dominated by F19,F20,F21 accuracy are the worst ones + # If needed, these Fs can be improved. + np.testing.assert_allclose(aNSqq3, 0.0, atol=5e-3) + + N = 2.0 + sx = get_sx(N) + smx = get_smx(N) + s3x = get_s3x(N, sx, smx) + s4x = get_s4x(N, sx, smx) + # reference value comes form Mathematica, gg is not fullycomplete + # thus the reference value is not 0.0 + # Here the accuracy of this test depends on the approximation of AggTF2 + np.testing.assert_allclose( + n3lo.A_gg_3(N, sx, smx, s3x, s4x, nf, L) + + n3lo.A_qg_3(N, sx, smx, s3x, s4x, nf, L) + + n3lo.A_Hg_3(N, sx, smx, s3x, s4x, nf, L), + 145.148, + rtol=32e-3, + ) # here you get division by 0 as in Mathematica # np.testing.assert_allclose( - # n3lo.A_gq_3(N, sx, smx, s3x, s4x, nf) - # + n3lo.A_qqNS_3(N, sx, smx, s3x, s4x, nf) - # + n3lo.A_qqPS_3(N, sx, nf) - # + n3lo.A_Hq_3(N, sx, smx, s3x, s4x, nf), + # n3lo.A_gq_3(N, sx, smx, s3x, s4x, nf,L) + # + n3lo.A_qqNS_3(N, sx, smx, s3x, s4x, nf,L) + # + n3lo.A_qqPS_3(N, sx, nf,L) + # + n3lo.A_Hq_3(N, sx, smx, s3x, s4x, nf,L), # 0.0, # atol=2e-6, # ) @@ -69,7 +71,7 @@ def test_A_3(): # sx_all = np.append(sx_all, get_smx(N)) # sx_all = np.append(sx_all, get_s3x(N, get_sx(N),get_smx(N))) # sx_all = np.append(sx_all, get_s4x(N, get_sx(N),get_smx(N))) - # aS3 = A_singlet_3(N, sx_all, nf) + # aS3 = A_singlet_3(N, sx_all, nf, L) # gluon momentum conservation # np.testing.assert_allclose(aS3[0, 0] + aS3[1, 0] + aS3[2, 0], 0.0, atol=2e-6) # quark momentum conservation @@ -77,8 +79,8 @@ def test_A_3(): N = 3 + 2j sx_all = np.random.rand(19) + 1j * np.random.rand(19) - aS3 = A_singlet_3(N, sx_all, nf) - aNS3 = A_ns_3(N, sx_all, nf) + aS3 = A_singlet_3(N, sx_all, nf, L) + aNS3 = A_ns_3(N, sx_all, nf, L) assert aNS3.shape == (2, 2) assert aS3.shape == (3, 3) @@ -87,49 +89,83 @@ def test_A_3(): def test_Bluemlein_3(): - # Test against Blumlein OME implementation :cite:`Bierenbaum:2009mv`. + # Test against Bluemlein OME implementation :cite:`Bierenbaum:2009mv`. # For singlet OME only even moments are available in that code. # Note there is a minus sign in the definition of L. # pylint: disable=too-many-locals + # reference N are 2,4,6,10,100 ref_val_gg = { - 0: [-440.104, -1377.49, -1683.31, -2006.18, -3293.81], + 0: [ + -440.1036857039252, + -1377.491100682841, + -1683.3145211964718, + -2006.179382743264, + -3293.80836498399, + ], + 10: [-18344.3, -41742.6, -50808.5, -61319.1, -108626.0], } # Mathematica not able to evaluate for N=100 ref_val_ggTF2 = { 0: [-33.4281, -187.903, -239.019, -294.571], + 10: [-33.4281, -187.903, -239.019, -294.571], } # diverging for N=2 ref_val_gq = { 0: [0, 22.7356, 16.4025, 10.5142, 0.98988], + 10: [0, 4408.98, 2488.62, 1281.9650, 53.907], } ref_val_Hg = { 0: [461.219, 682.728, 676.549, 626.857, 294.313], + 10: [ + 18487.47133439009, + 23433.42707514685, + 20705.71711303489, + 16377.933296134988, + 3386.8649353946803, + ], } ref_val_Hgstfac = { 0: [109.766, 64.7224, 25.1745, -11.5071, -37.9846], + 10: [109.766, 64.7224, 25.1745, -11.5071, -37.9846], } ref_val_Hq = { - 0: [15.6809, 1.82795, 1.01716, 0.595205, 0.0065763], + 0: [ + 15.680876575375834, + 1.827951379087708, + 1.0171574688383518, + 0.5952046986637233, + 0.006576376037629228, + ], + 10: [ + -9092.772439750246, + -1952.147452952931, + -856.1538615259986, + -314.27582798540243, + -3.467260112052196, + ], } ref_val_qg = { 0: [47.695, 44.8523, 32.6934, 19.8899, 0.397559], + 10: [-74.4038, -1347.17, -1278.72, -1080.31, -291.084], } ref_val_qqNS = { 0: [-37.0244, -40.1562, -36.0358, -28.3506, 6.83759], + 10: [-7574.85, -14130.3, -17928.6, -22768.0, -45425.9], } ref_val_qqPS = { 0: [-8.65731, -0.766936, -0.0365199, 0.147675, 0.0155598], + 10: [1672.99, 260.601, 112.651, 43.5204, 0.756621], } nf = 3 for i, N in enumerate([4.0, 6.0, 10.0, 100.0]): idx = i + 1 - for L in ref_val_Hg: + for L in [0, 10]: sx_all = get_sx(N) sx_all = np.append(sx_all, get_smx(N)) sx_all = np.append(sx_all, get_s3x(N, get_sx(N), get_smx(N))) sx_all = np.append(sx_all, get_s4x(N, get_sx(N), get_smx(N))) - aS3 = A_singlet_3(N, sx_all, nf) + aS3 = A_singlet_3(N, sx_all, nf, L) # here we have a different approximation for AggTF2, # some terms are neglected @@ -145,7 +181,7 @@ def test_Bluemlein_3(): ) np.testing.assert_allclose( - aS3[2, 1], ref_val_Hq[L][idx], rtol=2e-5, atol=1e-5 + aS3[2, 1], ref_val_Hq[L][idx], rtol=2e-5, atol=3e-6 ) # here we have a different convention for (-1)^N, @@ -171,21 +207,21 @@ def test_Bluemlein_3(): np.testing.assert_allclose(Aggtf2, ref_ggTF_app[idx], rtol=2e-4) np.testing.assert_allclose( - n3lo.agg.A_gg_3(N, sx, smx, s3x, s4x, nf) - Aggtf2, + n3lo.agg.A_gg_3(N, sx, smx, s3x, s4x, nf, L=0) - Aggtf2, ref_val_gg[0][idx], rtol=3e-6, ) # odd numbers of qqNS # Limited accuracy due to F functions - ref_qqNS_odd = [-40.95, -21.5988, 6.96633] + ref_qqNS_odd = [-40.94998646588999, -21.598793547423504, 6.966325573931755] for N, ref in zip([3.0, 15.0, 101.0], ref_qqNS_odd): sx = get_sx(N) smx = get_smx(N) s3x = get_s3x(N, sx, smx) s4x = get_s4x(N, sx, smx) np.testing.assert_allclose( - n3lo.aqqNS.A_qqNS_3(N, sx, smx, s3x, s4x, nf), ref, rtol=3e-2 + n3lo.aqqNS.A_qqNS_3(N, sx, smx, s3x, s4x, nf, L=0), ref, rtol=3e-2 ) @@ -217,5 +253,5 @@ def test_AHq_asymptotic(): s3x = get_s3x(N, sx, smx) s4x = get_s4x(N, sx, smx) np.testing.assert_allclose( - n3lo.aHq.A_Hq_3(N, sx, smx, s3x, s4x, nf), r, rtol=1e-5, atol=1e-5 + n3lo.aHq.A_Hq_3(N, sx, smx, s3x, s4x, nf, L=0), r, rtol=1e-5, atol=1e-5 ) From 9a49c3aee38b2b923b1c4281f05b513225b30bf2 Mon Sep 17 00:00:00 2001 From: Giacomo Magni Date: Fri, 10 Dec 2021 15:21:09 +0100 Subject: [PATCH 67/71] Fix dump to file navigator --- backward_paper/evolve_backward.py | 20 +++++++++++++++++--- backward_paper/navigator.py | 8 +++++--- 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 40eb2a049..4befc06a5 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -30,7 +30,7 @@ class BackwardRunner(BackwardPaperRunner): "kcThr": 1.0, "kbThr": 1.0, "ktThr": 1.0, - "PTO": 3, + "PTO": 2, "IC": 1, "IB": 1, "ModEv": "EXA", @@ -197,13 +197,16 @@ def evolve_backward_mass_variation( # pdf_name = "NNPDF40_nnlo_as_01180" # myrunner.evolve_backward(pdf_name, q_low=1.5101, q_high=1.65, return_to_Q0=False) - # # charm mass variations + # # charm mass variations, + # # and eko for momentum fractions # mass_variations = { # 1.38: "211103-ern-001", # NNPDF40 baseline with mc=1.38 # 1.64: "211103-ern-002", # NNPDF40 baseline with mc=1.64 + # # 1.51: "NNPDF40_nnlo_as_01180", # NNLO, fitted charm + # # 1.51: "NNPDF40_nnlo_as_01180_EMC", # NNPDF40 baseline, fitted charm + EMC F2c # } # for c_m, pdf_name in mass_variations.items(): - # myrunner.evolve_backward_mass_variation(pdf_name, q_high=1.65, charm_mass=c_m) + # myrunner.evolve_backward_mass_variation(pdf_name, q_high=1.65, charm_mass=c_m, epsilon=1e-4) # # dataset_variations # pdf_names =[ @@ -216,3 +219,14 @@ def evolve_backward_mass_variation( # for name in pdf_names: # # Simple inversion # myrunner.evolve_backward(name) + + # # Evolve above thr for RW fits + pdf_names = [ + "211112-tg-001", # Uncorrelated sys + "211112-tg-002", # Correlated sys + "NNPDF40_nnlo_as_01180", + ] + for pdf_name in pdf_names: + myrunner.evolve_backward( + pdf_name, q_low=1.5101, q_high=1.65, return_to_Q0=False + ) diff --git a/backward_paper/navigator.py b/backward_paper/navigator.py index 1dd65b58a..5ce2f538f 100644 --- a/backward_paper/navigator.py +++ b/backward_paper/navigator.py @@ -193,10 +193,12 @@ def dump_logs( total_log, log_name = self.collect_logs(hashes, label_to_display) if rotate_to_pm_basis: total_log = to_pm(total_log, skip) - + # cast to dict + for pdf, table in total_log.items(): + total_log[pdf] = table.to_dict() + # dump with open(f"{log_name}.json", "w") as f: - for pdf, table in total_log.items(): - json.dump({pdf: table.to_dict()}, f) + json.dump(total_log, f) f.close() def compute_momentum_fraction( From ac15b17b56473ce36aa367c0c1ca2f1bffb44026 Mon Sep 17 00:00:00 2001 From: Giacomo Magni Date: Fri, 10 Dec 2021 15:23:06 +0100 Subject: [PATCH 68/71] update runners --- backward_paper/evolve_backward.py | 9 ++--- backward_paper/q2_study.py | 63 ++++++++++++++++++++++++++++--- benchmarks/runners/NNPDF_bench.py | 11 ++++-- 3 files changed, 70 insertions(+), 13 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 4befc06a5..4b719e614 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -6,7 +6,7 @@ from ekomark.data import operators -from eko.interpolation import make_lambert_grid +from eko.interpolation import make_lambert_grid, make_grid from runner import BackwardPaperRunner @@ -36,10 +36,8 @@ class BackwardRunner(BackwardPaperRunner): "ModEv": "EXA", } base_operator = { - "interpolation_xgrid": [make_lambert_grid(60, x_min=1e-3).tolist()], - # "interpolation_xgrid": [np.linspace(1e-2,1,50)], - # "interpolation_xgrid": [make_grid(30,10).tolist()], - # "interpolation_xgrid": [make_lambert_grid(50).tolist()], + # "interpolation_xgrid": [make_lambert_grid(60, x_min=1e-3).tolist()], + "interpolation_xgrid": [make_grid(20, 30, x_min=1e-2).tolist()], # "interpolation_polynomial_degree": [1], "backward_inversion": ["exact"], # "ev_op_iterations": [1], @@ -225,6 +223,7 @@ def evolve_backward_mass_variation( "211112-tg-001", # Uncorrelated sys "211112-tg-002", # Correlated sys "NNPDF40_nnlo_as_01180", + "NNPDF40_nnlo_as_01180_EMC", ] for pdf_name in pdf_names: myrunner.evolve_backward( diff --git a/backward_paper/q2_study.py b/backward_paper/q2_study.py index 446dd7131..b94adc7d5 100644 --- a/backward_paper/q2_study.py +++ b/backward_paper/q2_study.py @@ -6,7 +6,7 @@ from banana.data import cartesian_product from ekomark.data import operators -from eko.interpolation import make_grid +from eko.interpolation import make_grid, make_lambert_grid from runner import BackwardPaperRunner @@ -42,7 +42,7 @@ class Q2gridRunner(BackwardPaperRunner): def evolve_different_q2(self, pdf_name, q_low=1.5, q_grid=[1.65, 10.0, 100.0]): """ - Evolve pdf at differnt Q2 values + Evolve pdf at different Q2 values Parameters ---------- @@ -68,15 +68,56 @@ def evolve_different_q2(self, pdf_name, q_low=1.5, q_grid=[1.65, 10.0, 100.0]): use_replicas=True, ) + def check_light_q_gluon(self, pdf_name, q_to, q_from=1.65): + """ + Evolve pdf to different Q2 values, store all the pdfs in eveolution + basis + + Parameters + ---------- + pdf_name: str + PDF name + q_from: float + initial Q scale + q_to: list + final Q scales + """ + + self.fig_name = pdf_name + self.plot_pdfs = ["g", "V", "S", "V3", "V8", "V15", "T3", "T8", "T15"] + self.rotate_to_evolution_basis = True + + theory_updates = self.base_theory.copy() + theory_updates["Q0"] = [q_from] + theory_updates["PTO"] = [2, 3] + theory_updates["ModEv"] = ["TRN"] + + operator_updates = self.base_operator.copy() + operator_updates.update( + { + "Q2grid": [list(np.power(q_to, 2))], + "interpolation_xgrid": [make_lambert_grid(60).tolist()], + "backward_inversion": ["exact"], + "ev_op_iterations": [1], + } + ) + + self.run( + cartesian_product(theory_updates), + operators.build((operator_updates)), + [pdf_name], + use_replicas=True, + ) + if __name__ == "__main__": myrunner = Q2gridRunner() # Pch evolution - name = "NNPDF40_nnlo_pch_as_01180" - q_grid = [1.65, 10, 100] - myrunner.evolve_different_q2(name, q_grid=q_grid) + # name = "NNPDF40_nnlo_pch_as_01180" + # q_grid = [1.65, 10, 100] + # myrunner.evolve_different_q2(name, q_grid=q_grid) # Fitted charm evolution # pdf_names = { @@ -85,3 +126,15 @@ def evolve_different_q2(self, pdf_name, q_low=1.5, q_grid=[1.65, 10.0, 100.0]): # } # for name, q_grid in pdf_names.items(): # myrunner.evolve_different_q2(name, q_low=1.65, q_grid=q_grid) + + # Baseline vs Pch evolution to 1 GeV + pdf_name = [ + "NNPDF40_nnlo_as_01180", + "NNPDF40_nnlo_pch_as_01180", + ] + for name in pdf_name: + myrunner.check_light_q_gluon(name, q_to=[1.0]) + + # add pch at 1.0 with lhapdf + pdf_name = "NNPDF40_nnlo_pch_as_01180" + myrunner.check_light_q_gluon(pdf_name, q_to=[1.0], q_from=1.0) diff --git a/benchmarks/runners/NNPDF_bench.py b/benchmarks/runners/NNPDF_bench.py index 7c5bb99c9..a6c769261 100644 --- a/benchmarks/runners/NNPDF_bench.py +++ b/benchmarks/runners/NNPDF_bench.py @@ -90,7 +90,11 @@ def benchmark_pch(self, Q0=1.5, Q2grid=(1.65 ** 2,)): "Q0": Q0, } - operator_card = {**base_operator, "Q2grid": list(Q2grid)} + operator_card = { + **base_operator, + "Q2grid": list(Q2grid), + "backward_inversion": "exact" + } self.run([theory_card], [operator_card], ["NNPDF40_nnlo_pch_as_01180"]) @@ -104,5 +108,6 @@ def benchmark_pch(self, Q0=1.5, Q2grid=(1.65 ** 2,)): # #nn31.benchmark_nlo(Q0=np.sqrt(high2), Q2grid=[low2]) nn40 = BenchmarkNNPDF40() # nn40.benchmark_nlo(Q2grid=[100]) - nn40.benchmark_nnlo(Q2grid=[100]) - # nn40.benchmark_pch() + # nn40.benchmark_nnlo(Q2grid=[100]) + # nn40.benchmark_pch(Q0=1.65, Q2grid=(1.0**2,)) + nn40.benchmark_pch() From f080ffa9dec215df101a51cf3db43824ffd112f2 Mon Sep 17 00:00:00 2001 From: Giacomo Magni Date: Fri, 10 Dec 2021 15:25:35 +0100 Subject: [PATCH 69/71] Small fix on is_backward, no need to explicit IC --- src/eko/matching_conditions/operator_matrix_element.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index 35bb420e5..7d6b7019e 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -399,7 +399,10 @@ class OperatorMatrixElement: def __init__(self, config, managers, is_backward, mellin_cut=1e-2): self.backward_method = config["backward_inversion"] if is_backward else "" - self.is_intrinsic = bool(len(config["intrinsic_range"]) != 0) + if is_backward: + self.is_intrinsic = True + else: + self.is_intrinsic = bool(len(config["intrinsic_range"]) != 0) self.config = config self.sc = managers["strong_coupling"] self.int_disp = managers["interpol_dispatcher"] From 5d9e3782458069ed73ed21059f03a526d2949cbb Mon Sep 17 00:00:00 2001 From: Giacomo Magni Date: Mon, 10 Jan 2022 10:32:08 +0100 Subject: [PATCH 70/71] update evolve backward --- backward_paper/evolve_backward.py | 74 +++++++++++++++++++------------ backward_paper/plots.py | 1 + 2 files changed, 47 insertions(+), 28 deletions(-) diff --git a/backward_paper/evolve_backward.py b/backward_paper/evolve_backward.py index 4b719e614..5bbbe6a02 100644 --- a/backward_paper/evolve_backward.py +++ b/backward_paper/evolve_backward.py @@ -36,8 +36,11 @@ class BackwardRunner(BackwardPaperRunner): "ModEv": "EXA", } base_operator = { - # "interpolation_xgrid": [make_lambert_grid(60, x_min=1e-3).tolist()], - "interpolation_xgrid": [make_grid(20, 30, x_min=1e-2).tolist()], + "interpolation_xgrid": [make_lambert_grid(60).tolist()], + # "interpolation_xgrid": [make_lambert_grid(60, x_min=1e-2).tolist()], + # "interpolation_xgrid": [make_grid(20, 30, x_min=1e-2).tolist()], + # "interpolation_xgrid": [make_grid(50, 10, x_low=0.8, x_min=1e-2).tolist()], + # "interpolation_xgrid": [make_grid(30, 10, x_low=0.6, x_min=1e-2).tolist()], # "interpolation_polynomial_degree": [1], "backward_inversion": ["exact"], # "ev_op_iterations": [1], @@ -162,20 +165,16 @@ def evolve_backward_mass_variation( myrunner = BackwardRunner() - # Evolve below c threshold - pdf_names = [ - "NNPDF40_nnlo_as_01180", # NNLO, fitted charm - # "NNPDF40_nnlo_pch_as_01180", # NNLO, perturbative charm - # "210701-n3fit-meth-013", # NNPDF4.0 in flavour basis - ] + # Basic checks + # pdf_names = [ + # "NNPDF40_nnlo_as_01180", # NNLO, fitted charm + # # "NNPDF40_nnlo_pch_as_01180", # NNLO, perturbative charm + # ] # for name in pdf_names: - # # Simple inversion # myrunner.evolve_backward(name) - # # Test beclow above thr # myrunner.evolve_above_below_thr(name) - # # Test exapanded/exact # myrunner.evolve_exact_expanded(name) @@ -195,16 +194,24 @@ def evolve_backward_mass_variation( # pdf_name = "NNPDF40_nnlo_as_01180" # myrunner.evolve_backward(pdf_name, q_low=1.5101, q_high=1.65, return_to_Q0=False) - # # charm mass variations, - # # and eko for momentum fractions + # # charm mass variations, also used for momentum fractions # mass_variations = { # 1.38: "211103-ern-001", # NNPDF40 baseline with mc=1.38 # 1.64: "211103-ern-002", # NNPDF40 baseline with mc=1.64 - # # 1.51: "NNPDF40_nnlo_as_01180", # NNLO, fitted charm - # # 1.51: "NNPDF40_nnlo_as_01180_EMC", # NNPDF40 baseline, fitted charm + EMC F2c + # 1.51: "NNPDF40_nnlo_as_01180", # NNLO, fitted charm + # 1.51: "NNPDF40_nnlo_as_01180_EMC", # NNPDF40 baseline, fitted charm + EMC F2c # } # for c_m, pdf_name in mass_variations.items(): - # myrunner.evolve_backward_mass_variation(pdf_name, q_high=1.65, charm_mass=c_m, epsilon=1e-4) + # myrunner.evolve_backward_mass_variation(pdf_name, q_high=1.65, charm_mass=c_m, epsilon=1e-8) + + # mass variation perturbative charm, forward evolution + # mass_variations_pch = { + # 1.38: "211103-ern-003", # NNPDF40 baseline with mc=1.38 + # 1.64: "211103-ern-004", # NNPDF40 baseline with mc=1.64 + # 1.51: "NNPDF40_nnlo_pch_as_01180", # NNLO, fitted charm + # } + # for c_m, pdf_name in mass_variations_pch.items(): + # myrunner.evolve_backward_mass_variation(pdf_name, q_high=c_m-1e-8, charm_mass=c_m, epsilon=c_m-1.65) # # dataset_variations # pdf_names =[ @@ -215,17 +222,28 @@ def evolve_backward_mass_variation( # "NNPDF40_nnlo_as_01180", # NNLO, fitted charm # ] # for name in pdf_names: - # # Simple inversion # myrunner.evolve_backward(name) - # # Evolve above thr for RW fits - pdf_names = [ - "211112-tg-001", # Uncorrelated sys - "211112-tg-002", # Correlated sys - "NNPDF40_nnlo_as_01180", - "NNPDF40_nnlo_as_01180_EMC", - ] - for pdf_name in pdf_names: - myrunner.evolve_backward( - pdf_name, q_low=1.5101, q_high=1.65, return_to_Q0=False - ) + # # Evolve above thr for RW fits inclding LHCb Z+c + # pdf_names = [ + # "NNPDF40_nnlo_as_0118_LHCbZc_uncorr", # Uncorrelated sys + # "NNPDF40_nnlo_as_0118_LHCbZc_corr", # Correlated sys + # "NNPDF40_nnlo_as_0118_EMC_LHCbZc_uncorr", # Uncorrelated sys + # "NNPDF40_nnlo_as_0118_EMC_LHCbZc_corr", # Correlated sys + # "NNPDF40_nnlo_as_01180", + # "NNPDF40_nnlo_as_01180_EMC", + # ] + # for pdf_name in pdf_names: + # myrunner.evolve_backward( + # pdf_name, q_low=1.50, q_high=1.65, return_to_Q0=False + # ) + + # Flavor basis vs 4.0 comparison + # pdf_names = [ + # "210701-n3fit-meth-013", + # "NNPDF40_nnlo_as_01180" + # ] + # for pdf_name in pdf_names: + # myrunner.evolve_backward( + # pdf_name, q_low=1.51-1e-8, q_high=1.65, return_to_Q0=False + # ) diff --git a/backward_paper/plots.py b/backward_paper/plots.py index a8d0e8d4c..086fcc014 100644 --- a/backward_paper/plots.py +++ b/backward_paper/plots.py @@ -88,6 +88,7 @@ def plot_pdf(log, fig_name, cl=1, plot_pull=False, plot_reldiff=False): ax.set_ylabel(r"\rm{x %s(x)}" % quark_latex_name(name), fontsize=11) ax.set_xscale("log") else: + # ax.set_ylim(-0.05, 0.04) ax.set_yscale("symlog", linthresh=1e-6 if y_min < 1e-6 else y_min) if plot_pull: From 497773932f048a8e0c5873be87df082dd4dd0b25 Mon Sep 17 00:00:00 2001 From: Alessandro Candido Date: Mon, 10 Jan 2022 16:55:01 +0100 Subject: [PATCH 71/71] Add environments dump --- env_back_op_gen.txt | 115 ++++++++++++++++++++++ env_plots.txt | 225 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 340 insertions(+) create mode 100644 env_back_op_gen.txt create mode 100644 env_plots.txt diff --git a/env_back_op_gen.txt b/env_back_op_gen.txt new file mode 100644 index 000000000..a22e504fb --- /dev/null +++ b/env_back_op_gen.txt @@ -0,0 +1,115 @@ +# Dump of environment used to generate backward evolution operators +# notes: +# - banana version used does not correspond to any one available on PyPI +# (see below) even though should not be relevant to generate operators +# - LHAPDF is not available as a package on PyPI, installed from: +# https://github.com/N3PDF/external/tree/afd30d08f95ed96e4b03df21e0ecc1d284a7292e +alabaster==0.7.12 +astroid==2.8.0 +attrs==21.2.0 +Babel==2.9.1 +backcall==0.2.0 +backports.entry-points-selectable==1.1.0 +# actual banana used: +# https://github.com/N3PDF/banana/tree/daf1a47017407a2e3b4bef9a4920f0ed90f1de1a +banana-hep==0.4.0 +black==21.9b0 +certifi==2021.10.8 +cffi==1.14.6 +cfgv==3.3.1 +charset-normalizer==2.0.7 +click==8.0.1 +colorama==0.4.4 +commonmark==0.9.1 +coverage==6.0 +cycler==0.10.0 +dataclasses==0.8 +decorator==5.1.0 +distlib==0.3.3 +docutils==0.17.1 +eko==0.7.3 +ekomark==0.1.0 +filelock==3.3.2 +flameprof==0.4 +greenlet==1.1.2 +human-dates2==1.2.0 +identify==2.3.3 +idna==3.3 +imagesize==1.2.0 +iniconfig==1.1.1 +ipython==7.28.0 +isort==5.9.3 +jedi==0.18.0 +Jinja2==3.0.1 +kiwisolver==1.3.2 +latexcodec==2.0.1 +lazy-object-proxy==1.6.0 +LHAPDF==6.4.0 +llvmlite==0.37.0 +lz4==3.1.3 +MarkupSafe==2.0.1 +matplotlib==3.4.3 +matplotlib-inline==0.1.3 +mccabe==0.6.1 +more-itertools==8.10.0 +mpmath==1.2.1 +mypy-extensions==0.4.3 +nodeenv==1.6.0 +numba==0.54.0 +numpy==1.20.3 +packaging==21.0 +packutil==0.0.4 +pandas==1.3.3 +parso==0.8.2 +pathspec==0.9.0 +pexpect==4.8.0 +pickleshare==0.7.5 +Pillow==8.3.2 +pip==21.2.4 +platformdirs==2.4.0 +pluggy==1.0.0 +pre-commit==2.15.0 +prompt-toolkit==3.0.20 +ptyprocess==0.7.0 +py==1.10.0 +pybtex==0.24.0 +pybtex-docutils==1.0.1 +pycparser==2.20 +pygit2==1.6.1 +Pygments==2.10.0 +pylint==2.11.1 +pyparsing==2.4.7 +pytest==6.2.5 +pytest-cov==2.12.1 +pytest-env==0.6.2 +python-dateutil==2.8.2 +pytz==2021.3 +PyYAML==5.4.1 +regex==2021.9.30 +requests==2.26.0 +rich==10.11.0 +scipy==1.7.1 +semver==2.13.0 +setuptools==58.0.4 +six==1.16.0 +snowballstemmer==2.1.0 +Sphinx==4.2.0 +sphinx-rtd-theme==1.0.0 +sphinxcontrib-applehelp==1.0.2 +sphinxcontrib-bibtex==2.4.1 +sphinxcontrib-devhelp==1.0.2 +sphinxcontrib-htmlhelp==2.0.0 +sphinxcontrib-jsmath==1.0.1 +sphinxcontrib-qthelp==1.0.3 +sphinxcontrib-serializinghtml==1.1.5 +SQLAlchemy==1.4.25 +toml==0.10.2 +tomli==1.2.1 +traitlets==5.1.0 +typed-ast==1.4.3 +typing-extensions==3.10.0.2 +urllib3==1.26.7 +virtualenv==20.10.0 +wcwidth==0.2.5 +wheel==0.37.0 +wrapt==1.12.1 diff --git a/env_plots.txt b/env_plots.txt new file mode 100644 index 000000000..330b87402 --- /dev/null +++ b/env_plots.txt @@ -0,0 +1,225 @@ +# Dump of environment used to make paper plots +# notes: +# - banana version used does not correspond to any one available on PyPI +# (see below) +# - APFEL, LHAPDF, QCDNUM, and Pegasus are not available as packages on PyPI +# installed from: +# https://github.com/N3PDF/external/tree/afd30d08f95ed96e4b03df21e0ecc1d284a7292e +alabaster==0.7.12 +anyio==3.1.0 +APFEL==3.0.5 +appdirs==1.4.4 +appnope==0.1.2 +arcana==0.6.1 +argon2-cffi==20.1.0 +astroid==2.5.1 +async-generator==1.10 +attrs==20.3.0 +Babel==2.9.0 +backcall==0.2.0 +# actual banana used: +# https://github.com/N3PDF/banana/tree/daf1a47017407a2e3b4bef9a4920f0ed90f1de1a +banana-hep==0.4.3 +bids-validator==1.6.0 +black==21.10b0 +bleach==3.3.0 +brotlipy==0.7.0 +CacheControl==0.12.8 +cached-property==1.5.2 +cachy==0.3.0 +certifi==2021.10.8 +cffi==1.14.5 +cfgv==3.3.0 +chardet==4.0.0 +ci-info==0.2.0 +cleo==0.8.1 +click==7.1.2 +clikit==0.6.2 +colorama==0.4.4 +commonmark==0.9.1 +contextlib2==0.6.0.post1 +coverage==5.5 +crashtest==0.3.1 +cryptography==3.4.7 +cycler==0.10.0 +decorator==5.0.6 +deepdiff==5.2.2 +defusedxml==0.7.1 +distlib==0.3.2 +docopt==0.6.2 +docutils==0.17 +dunamai==1.7.0 +eko==0.7.3 +ekomark==0.1.0 +entrypoints==0.3 +etelemetry==0.2.2 +fancy-dict==0.0.0 +fancycompleter==0.9.1 +fasteners==0.16 +filelock==3.0.12 +future==0.18.2 +html5lib==1.1 +human-dates2==1.2.0 +identify==2.2.10 +idna==2.10 +imagesize==1.2.0 +importlib-metadata==3.10.0 +iniconfig==1.1.1 +ipykernel==5.5.5 +ipython==7.19.0 +ipython-genutils==0.2.0 +isodate==0.6.0 +isort==5.7.0 +jedi==0.17.0 +Jinja2==2.11.3 +json5==0.9.5 +jsonschema==3.2.0 +jupyter-client==6.1.12 +jupyter-core==4.7.1 +jupyter-server==1.8.0 +jupyterlab==3.0.16 +jupyterlab-mathjax3==4.2.2 +jupyterlab-pygments==0.1.2 +jupyterlab-server==2.6.0 +keyring==21.8.0 +kiwisolver==1.3.1 +latexcodec==2.0.1 +lazy-object-proxy==1.5.2 +LHAPDF==6.3.0 +llvmlite==0.36.0 +lockfile==0.12.2 +lxml==4.6.2 +lz4==3.1.3 +MarkupSafe==1.1.1 +mathjax==0.1.2 +matplotlib==3.4.3 +mccabe==0.6.1 +mistune==0.8.4 +mkl-fft==1.3.0 +mkl-random==1.1.1 +mkl-service==2.3.0 +more-itertools==8.7.0 +mpi4py==3.0.3 +mpmath==1.2.1 +msgpack==1.0.2 +mypy-extensions==0.4.3 +nbclassic==0.3.1 +nbclient==0.5.3 +nbconvert==6.0.7 +nbformat==5.1.3 +nbsphinx==0.8.1 +nest-asyncio==1.5.1 +networkx==2.5 +nibabel==3.2.1 +nipype==1.6.0 +nodeenv==1.6.0 +notebook==6.4.0 +num2words==0.5.10 +numba==0.53.1 +numpy==1.20.2 +olefile==0.46 +ordered-set==4.0.2 +packaging==20.9 +packutil==0.0.4 +pandas==1.3.0 +pandocfilters==1.4.3 +parso==0.8.2 +pastel==0.2.1 +pathspec==0.9.0 +patsy==0.5.1 +pdbpp==0.10.0 +pegasus==0.1.0 +pexpect==4.8.0 +pickleshare==0.7.5 +Pillow==8.2.0 +pip==21.3.1 +pkginfo==1.7.1 +platformdirs==2.4.0 +pluggy==0.13.1 +poetry==1.1.11 +poetry-core==1.0.7 +poetry-dynamic-versioning==0.13.1 +pre-commit==2.13.0 +progress==1.5 +progressbar2==3.53.1 +prometheus-client==0.11.0 +prompt-toolkit==3.0.17 +prov==2.0.0 +ptyprocess==0.7.0 +py==1.10.0 +pyaml==20.4.0 +pybids==0.12.4 +pybtex==0.24.0 +pybtex-docutils==1.0.0 +pycparser==2.20 +pydicom==2.1.2 +pydot==1.4.2 +pygit2==1.6.0 +Pygments==2.8.1 +pylev==1.4.0 +pylint==2.7.2 +pymultinest==2.11 +pyOpenSSL==20.0.1 +pyparsing==2.4.7 +PyPDF2==1.26.0 +pyrepl==0.9.0 +pyrsistent==0.17.3 +PySocks==1.7.1 +pytest==6.2.2 +pytest-cov==2.11.1 +pytest-env==0.6.2 +python-dateutil==2.8.1 +python-utils==2.5.6 +pytz==2021.1 +PyYAML==5.4.1 +pyzmq==20.0.0 +QCDNUM==0.1.0 +rdflib==5.0.0 +recommonmark==0.6.0 +regex==2021.4.4 +requests==2.25.1 +requests-toolbelt==0.9.1 +rich==9.10.0 +scipy==1.7.1 +semver==2.13.0 +Send2Trash==1.5.0 +setuptools==52.0.0.post20210125 +shellingham==1.4.0 +simplejson==3.17.2 +six==1.15.0 +smefit==0.1.0 +sniffio==1.2.0 +snowballstemmer==2.1.0 +Sphinx==4.0.2 +sphinx-rtd-theme==0.5.1 +sphinxcontrib-applehelp==1.0.2 +sphinxcontrib-bibtex==2.1.4 +sphinxcontrib-details-directive==0.1.0 +sphinxcontrib-devhelp==1.0.2 +sphinxcontrib-htmlhelp==1.0.3 +sphinxcontrib-jsmath==1.0.1 +sphinxcontrib-qthelp==1.0.3 +sphinxcontrib-serializinghtml==1.1.4 +SQLAlchemy==1.3.23 +terminado==0.10.0 +testpath==0.4.4 +tinydb==4.3.0 +toml==0.10.2 +tomli==1.2.2 +tomlkit==0.7.2 +tornado==6.1 +traitlets==5.0.5 +traits==6.2.0 +typed-ast==1.4.3 +typing-extensions==3.10.0.2 +urllib3==1.26.4 +virtualenv==20.4.7 +wcwidth==0.2.5 +webencodings==0.5.1 +websocket-client==1.0.1 +wheel==0.36.2 +wmctrl==0.3 +wrapt==1.12.1 +xnat==0.3.25 +xspace-bench==0.1 +zipp==3.4.1