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..e2903b40d --- /dev/null +++ b/backward_paper/banana.yaml @@ -0,0 +1,5 @@ +database_path: database.db +input_tables: + - theories + - operators + - cache 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 new file mode 100644 index 000000000..5bbbe6a02 --- /dev/null +++ b/backward_paper/evolve_backward.py @@ -0,0 +1,249 @@ +# -*- coding: utf-8 -*- +""" +This script compute an EKO to evolve a PDF set under the charm thrshold replica by replica +""" +import numpy as np + +from ekomark.data import operators + +from eko.interpolation import make_lambert_grid, make_grid + +from runner import BackwardPaperRunner + +pid_dict = {"c": 4, "b": 5, "t": 6} + + +class BackwardRunner(BackwardPaperRunner): + """ + This class evolve a pdf below the charm thrshold and + compare it with the initial pdf replica by replica. + """ + + 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": "EXA", + } + base_operator = { + "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], + } + + def doit( + self, pdf_name, operator_updates, theory_updates=None, q_high=None, q_low=None + ): + """Set common options and run""" + 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: + 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 + + Parameters + ---------- + pdf_name: str + PDF name + q_high: float + initial Q scale + q_low: float + final Q scale + return_to_Q0: bool + if True compute also the EKO back to test stability + """ + 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]}" # pylint: disable=line-too-long + 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] + + operator_updates["Q2grid"] = [[q_low ** 2], [q_high ** 2], [q_high ** 2]] + theory_updates["Q0"] = [q_high, q_low, q_high] + 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) + + 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 + + Parameters + ---------- + 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_{heavy_quark}_{pdf_name}" + self.plot_pdfs = [-pid_dict[heavy_quark], pid_dict[heavy_quark]] + + 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"] = [ + 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): + operator_updates = self.base_operator.copy() + 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__": + + myrunner = BackwardRunner() + + # 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) + + # # Test perturbarive B + # pdf_name = "NNPDF40_nnlo_as_01180" + # 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=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) + + # # 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, 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 + # } + # 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-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 =[ + # "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: + # myrunner.evolve_backward(name) + + # # 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/navigator.py b/backward_paper/navigator.py new file mode 100644 index 000000000..5ce2f538f --- /dev/null +++ b/backward_paper/navigator.py @@ -0,0 +1,281 @@ +# -*- coding: utf-8 -*- +""" +This script contains a specialization of the Ekomark navigator +""" +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 +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 + + +def replace_label(new_label): + return lambda s: s.replace("EKO", f"{new_label}") + + +class NavigatorApp(Ekonavigator): + """ + Specialization of the Ekomark navigator. + """ + + 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] + + @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 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"] + 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"]) + label = theory[key] + if key == "PTO": + pto_dict = {0: "LO", 1: "NLO", 2: "NNLO", 3: "N3LO"} + label = pto_dict[label] + 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 collect_logs( + self, + hashes, + label_to_display=None, + ): + """ + Collect logs with the same x grid and raname labels + + Parameters + ---------- + hashes : list + log hash list to plot + label_to_display: str + key to display in the plot legend: 'pdf' or theory/operator key + """ + + dfds = [] + labels = [] + log_name = "" + for h in hashes: + log = self.get(bnav.l, h) + dfds.append(log["log"]) + 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 + log_name = log_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(tab).rename( + columns=replace_label(labels[n]) + ) + # set the other tables + else: + 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 + + 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, + plot_reldiff=plot_reldiff, + 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) + # 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: + json.dump(total_log, f) + f.close() + + def compute_momentum_fraction( + self, hashes, label_to_display=None, rotate_to_pm_basis=True, skip=None + ): + """ + Compute the momentum fraction for each PDF + + 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 + """ + + 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 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) + + +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 +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 +# 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 new file mode 100644 index 000000000..086fcc014 --- /dev/null +++ b/backward_paper/plots.py @@ -0,0 +1,129 @@ +# -*- coding: utf-8 -*- +""" +Plotting options +""" +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) + + +def quark_latex_name(name): + quark_name = name + if "bar" in name: + quark_name = r"$\bar{%s}$" % name[0] + return quark_name + + +def plot_pdf(log, fig_name, cl=1, plot_pull=False, plot_reldiff=False): + """ + Plotting routine + + Parameters + ---------- + log: dict + log table + fig_name: str + Figure name + cl: int + confidence level interval ( in units of sigma ) + """ + 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) if has_ratio else fig.add_gridspec(1, 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 with pull + # col=0 has log x, clo=1 has linear x + for ncol in [0, 1]: + + 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(): + ax.plot(mean.x, column_data) + 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"\ ")).replace( + ">", r"$\rightarrow$" + ) + ) + ) + if np.abs(column_data.min()) < np.abs(y_min): + y_min = np.abs(column_data.min()) + + 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) + + if ncol == 0: + 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: + 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{Evidence}", fontsize=11) + elif plot_reldiff: + ax_ratio = plt.subplot(gs[-1:, ncol], sharex=ax) + ref_data = mean.iloc[:, 1] + 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=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 + ) + 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/q2_study.py b/backward_paper/q2_study.py new file mode 100644 index 000000000..b94adc7d5 --- /dev/null +++ b/backward_paper/q2_study.py @@ -0,0 +1,140 @@ +# -*- 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, make_lambert_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": [3], + "IC": [1], + "IB": [1], + "ModEv": ["TRN"], + } + 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, q_grid=[1.65, 10.0, 100.0]): + """ + Evolve pdf at different Q2 values + + Parameters + ---------- + pdf_name: str + PDF name + q_low: float + initial Q scale + q_grid: list + final Q scales + """ + + 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(q_grid, 2))] + self.run( + cartesian_product(theory_updates), + operators.build((operator_updates)), + [pdf_name], + 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) + + # 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) + + # 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/backward_paper/runner.py b/backward_paper/runner.py new file mode 100644 index 000000000..f69bc4450 --- /dev/null +++ b/backward_paper/runner.py @@ -0,0 +1,201 @@ +# -*- coding: utf-8 -*- +""" +This script contains a specialization of the Ekomark runner +""" +import functools +import copy +import pandas as pd +import numpy as np + +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 +from config import pkg_path + +import eko + + +def rotate_to_pm_basis(log, skip=None): + """ + Rotate to plus minus basis + + Parameters + ---------- + log: dict + log table + skip: str + skip '+' or '-' + """ + rot_log = {} + skip = skip if skip is not None else [] + 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: + continue + quark = log[pid] + qbar = log[f"{pid}bar"].copy() + + 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:]: + if "error" in column_name: + continue + rot_log[r"${%s}^{%s}$" % (pid, key)][column_name] += ( + fact * qbar[column_name] + ) + return rot_log + + +class BackwardPaperRunner(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.plot_pdfs = [4, -4] + self.sandbox = True + self.fig_name = None + self.return_to_Q0 = False + self.ekos = [] + self.intermediate_Q = None + + 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? + 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 previous Ekos") + + # 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]) + + # 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) + return me + + def run_external(self, theory, ocard, pdf): + + if self.external == "inputpdf": + # Compare with the initial pdf + 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): + """Apply PDFs to eko and produce log tables""" + log_tabs = {} + xgrid = ocard["interpolation_xgrid"] + q2s = me["Q2grid"] + + rotate_to_evolution = None + if self.rotate_to_evolution_basis: + rotate_to_evolution = eko.basis_rotation.rotate_flavor_to_evolution.copy() + + pdf_name = get_pdf_name(pdf) + + # build table + tab = {} + tab["x"] = xgrid + + # Loop over pdfs replicas + for rep, pdf_set in enumerate(pdf): + pdf_grid = me.apply_pdf_flavor( + pdf_set, + xgrid, + flavor_rotation=rotate_to_evolution, + ) + + log_tab = dfdict.DFdict() + ref_pdfs = ext[rep] + + # Loop over pdf ids + for key in self.plot_pdfs: + + if self.external == "inputpdf": + tab[f'{pdf_name}_@_{theory["Q0"]}'] = ref_pdfs["values"][ + theory["Q0"] ** 2 + ][key] + + # Loop over q2 grid + for q2 in q2s: + res = pdf_grid[q2] + my_pdfs = res["pdfs"] + # 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)}" # pylint: disable=line-too-long + ] = (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 + + # 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 not self.rotate_to_evolution_basis + else new_log, + self.fig_name, + cl=1, + plot_reldiff=self.return_to_Q0, + ) + + return new_log diff --git a/backward_paper/submit_stoomboot.sh b/backward_paper/submit_stoomboot.sh new file mode 100755 index 000000000..9be8a1596 --- /dev/null +++ b/backward_paper/submit_stoomboot.sh @@ -0,0 +1,39 @@ +#!/bin/bash + +#GLOBAL PATHS +PY='/project/theorie/gmagni/miniconda3/envs/nnpdf/bin/python' + +function submit_job () { + + # RUN SETUP + RUNNAME=$1 + NCORES=$2 + WALLTIME=$3 + PYTHONSCRIPT=$4 + + + COMMAND=$PWD'/launch_'$RUNNAME'.sh' + RUNNER_PATH=$PWD + LOG_PATH=$PWD'/logs' + + LAUNCH=$PY' '$RUNNER_PATH'/'$PYTHONSCRIPT'.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' '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/benchmarks/ekomark/benchmark/external/lhapdf_utils.py b/benchmarks/ekomark/benchmark/external/lhapdf_utils.py index c3533cda6..2b3c228aa 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: + if pid in skip_pdfs or not pdf.hasFlavor(pid): 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 = { 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) 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/__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 6d5a77d3a..3600cc3ba 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): """ @@ -82,6 +88,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 +101,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 @@ -196,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 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) + + 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/CT14_bench.py b/benchmarks/runners/CT14_bench.py index dbbecbcda..da77e17d1 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 19603f79d..a6c769261 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 @@ -11,10 +10,12 @@ class BenchmarkNNPDF(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 def skip_pdfs(self, _theory): return [ @@ -82,6 +83,20 @@ 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), + "backward_inversion": "exact" + } + self.run([theory_card], [operator_card], ["NNPDF40_nnlo_pch_as_01180"]) + if __name__ == "__main__": # nn31 = BenchmarkNNPDF31() @@ -93,4 +108,6 @@ def benchmark_nnlo(self, Q0=1.65, Q2grid=(100,)): # #nn31.benchmark_nlo(Q0=np.sqrt(high2), Q2grid=[low2]) nn40 = BenchmarkNNPDF40() # nn40.benchmark_nlo(Q2grid=[100]) - nn40.benchmark_nnlo(Q2grid=[100]) + # nn40.benchmark_nnlo(Q2grid=[100]) + # nn40.benchmark_pch(Q0=1.65, Q2grid=(1.0**2,)) + nn40.benchmark_pch() 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/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) diff --git a/benchmarks/runners/lha_paper_bench.py b/benchmarks/runners/lha_paper_bench.py index b5270f03e..524d87521 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 0478d87c7..93d18630b 100644 --- a/benchmarks/runners/sandbox.py +++ b/benchmarks/runners/sandbox.py @@ -35,16 +35,23 @@ class Sandbox(Runner): - sandbox = True - # select here the external program between LHA, LHAPDF, apfel, pegasus - external = "apfel" - # external = "pegasus" + """ + Globally set the external program + """ - # select to plot operators - plot_operator = False + def __init__(self): + super().__init__() + self.sandbox = True - rotate_to_evolution_basis = True + # select here the external program between LHA, LHAPDF, apfel, pegasus + self.external = "apfel" + # external = "pegasus" + + # select to plot operators + self.plot_operator = False + + self.rotate_to_evolution_basis = True @staticmethod def generate_operators(): diff --git a/doc/source/refs.bib b/doc/source/refs.bib index d784a4a3c..e56461910 100644 --- a/doc/source/refs.bib +++ b/doc/source/refs.bib @@ -344,30 +344,172 @@ @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, - author = "Carrazza, S. and Nocera, E. R. and Schwan, C. and Zaro, M.", - title = "{PineAPPL: combining EW and QCD corrections for fast evaluation of LHC processes}", - eprint = "2008.12789", + title={PineAPPL: combining EW and QCD corrections for fast evaluation of LHC processes}, + volume={2020}, + ISSN={1029-8479}, + url={http://dx.doi.org/10.1007/JHEP12(2020)108}, + DOI={10.1007/jhep12(2020)108}, + number={12}, + journal={Journal of High Energy Physics}, + publisher={Springer Science and Business Media LLC}, + author={Carrazza, S. and Nocera, E. R. and Schwan, C. and Zaro, M.}, + year={2020}, + 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{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", - doi = "10.1007/JHEP12(2020)108", - journal = "JHEP", - volume = "12", - pages = "108", - year = "2020" + 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" +} + +@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" +} + +@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 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}, + 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 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}, + 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} } diff --git a/doc/source/theory/Matching.rst b/doc/source/theory/Matching.rst index 6baebbbd4..301091769 100644 --- a/doc/source/theory/Matching.rst +++ b/doc/source/theory/Matching.rst @@ -66,26 +66,32 @@ 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: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. + +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 +123,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/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 diff --git a/setup.py b/setup.py index 9daa90541..28395f92a 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/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/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/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/__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/n3lo/__init__.py b/src/eko/matching_conditions/n3lo/__init__.py new file mode 100644 index 000000000..da7da07bf --- /dev/null +++ b/src/eko/matching_conditions/n3lo/__init__.py @@ -0,0 +1,104 @@ +# -*- 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_Hg_3 +from .aHq import A_Hq_3 + + +@nb.njit("c16[:,:](c16,c16[:],u4,f8)", cache=True) +def A_singlet_3(n, sx_all, nf, L): + 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] + nf : int + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` + + 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] + s4x = sx_all[14:] + 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, L) + A_gg = A_gg_3(n, sx, smx, s3x, s4x, nf, L) + + 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]], + np.complex_, + ) + return A_S_3 + + +@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|. + + .. 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] + nf : int + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` + + 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] + s4x = sx_all[14:] + 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 new file mode 100644 index 000000000..5cf8308cd --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aHg.py @@ -0,0 +1,3808 @@ +# -*- coding: utf-8 -*- +# pylint: disable=too-many-lines +import numba as nb +import numpy as np + +from .aHgstfac import A_Hgstfac_3 + + +@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` + + 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 + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` + + 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] + S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] + 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)) + + 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)) + ) + ) + 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/aHgstfac.py b/src/eko/matching_conditions/n3lo/aHgstfac.py new file mode 100644 index 000000000..c69b03cdd --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aHgstfac.py @@ -0,0 +1,936 @@ +# -*- coding: utf-8 -*- +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] + 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/aHq.py b/src/eko/matching_conditions/n3lo/aHq.py new file mode 100644 index 000000000..0ba62b418 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aHq.py @@ -0,0 +1,2137 @@ +# -*- coding: utf-8 -*- +# pylint: disable=too-many-lines +import numpy as np +import numba as nb + + +@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). + + 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 + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` + + Returns + ------- + A_Hq_3 : complex + :math:`A_{Hq}^{S,(3)}(N)` + """ + 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] + 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: + 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 + ) + + # 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 + ) + ) + else: + # 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 + ) + + a_Hq_l0 = ( + 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) + # ) + + 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) + - 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)) + + H3fit + ) + + 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) + # ) + - 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)) + + ( + ( + -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)) + + H2fit + + ( + 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)) + ) + ) + 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 new file mode 100644 index 000000000..8b7fe5791 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/agg.py @@ -0,0 +1,1552 @@ +# -*- 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,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` + + 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 + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` + + 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] + S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] + a_gg_l0 = ( + -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)) + ) + ) + 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/aggTF2.py b/src/eko/matching_conditions/n3lo/aggTF2.py new file mode 100644 index 000000000..18b8bba02 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aggTF2.py @@ -0,0 +1,330 @@ +# -*- coding: utf-8 -*- +import numba as nb +import numpy as np + + +@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)` + prortional to :math:`T_{F}^2`. + 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. + + 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] + # 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 + * ( + -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) + * ( + -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) + ) + * binfact + ) + / ( + (-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) + * ( + 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) + ) + * binfact + ) + / ( + (-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 new file mode 100644 index 000000000..cbfa642b5 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/agq.py @@ -0,0 +1,987 @@ +# -*- coding: utf-8 -*- +import numba as nb +import numpy as np + + +@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) + + 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 + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` + + 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] + S31, S211, Sm22, Sm211, Sm31 = s4x[0], s4x[1], s4x[2], s4x[3], s4x[4] + a_gq_l0 = ( + 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)) + ) + ) + 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 new file mode 100644 index 000000000..f8a9949a1 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aqg.py @@ -0,0 +1,479 @@ +# -*- coding: utf-8 -*- +import numba as nb +import numpy as np + + +@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` + + 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 + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` + + 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] + S31, S211 = s4x[0], s4x[1] + a_qg_l0 = 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)) + ) + 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 new file mode 100644 index 000000000..ff04a94c5 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aqqNS.py @@ -0,0 +1,757 @@ +# -*- coding: utf-8 -*- +import numba as nb +import numpy as np + +from . import s_functions as sf + + +@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 + :cite:`Ablinger:2014vwa`. + 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 + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` + + 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] + 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) + a_qqNS_l0 = ( + 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 + ) + ) + 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 new file mode 100644 index 000000000..f138b804e --- /dev/null +++ b/src/eko/matching_conditions/n3lo/aqqPS.py @@ -0,0 +1,196 @@ +# -*- coding: utf-8 -*- +import numba as nb +import numpy as np + + +@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` + + Parameters + ---------- + n : complex + Mellin moment + sx : numpy.ndarray + list S1 ... S5 + nf : int + number of active flavor below the threshold + L : float + :math:`\ln(\mu_F^2 / m_h^2)` + + Returns + ------- + A_qqPS_3 : complex + :math:`A_{qq}^{PS,(3)}(N)` + """ + S1, S2, S3 = sx[0], sx[1], sx[2] + a_qqPS_l0 = ( + 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)) + ) + ) + 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/n3lo/f_functions.py b/src/eko/matching_conditions/n3lo/f_functions.py new file mode 100644 index 000000000..3fdcfda8d --- /dev/null +++ b/src/eko/matching_conditions/n3lo/f_functions.py @@ -0,0 +1,6971 @@ +# -*- 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` +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 + + +@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)", 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)", 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) + ) + ) + + +@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) + - 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): + """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) + - 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): + """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) + - 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): + """Linear combination of :math:`M[( 2 S_{2,2}(x)- Li_2(x)^2/2)/(1+x)](N)`""" + return ( + -0.5626569734260486 + + 0.49999902059348167 + * ( + (-1.6449340668482262 * (1 / (1.0 + n) + 1 / (2.0 + n) + S1)) / (2.0 + n) + + ( + 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 + * ( + -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 + * ( + 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 + * ( + ( + -1.6449340668482262 + * ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + ) + / (3.0 + n) + + ( + 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 + * ( + -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) + - ( + 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(3.0 + n, 2) + ) + ) + + 0.24954082848379078 + * ( + ( + -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 + ) + ) + / (4.0 + n) + + ( + 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 + * ( + -1.0 / np.power(4.0 + n, 5) + + 1.6449340668482262 / np.power(4.0 + n, 3) + - 0.8117424252833533 / (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.6449340668482262 + * ( + 1 / (1.0 + n) + + (3.0 + 2.0 * (1.0 + n)) / ((2.0 + n) * (3.0 + n)) + + S1 + ) + ) + / np.power(4.0 + n, 2) + - ( + 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) + ) + / (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 + * ( + ( + -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)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + ) + / (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) + ) + * (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 + * ( + -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 + ) + ) + / 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 + * ( + 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 + * ( + ( + -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 + * ( + -1.0 / np.power(6.0 + n, 5) + + 1.6449340668482262 / np.power(6.0 + n, 3) + - 0.8117424252833533 / (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.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)) + ) + / ((2.0 + n) * (3.0 + n) * (4.0 + n) * (5.0 + n)) + + S1 + ) + ) + / np.power(6.0 + n, 2) + - ( + 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) + ) + / ( + 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 + * ( + ( + -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) + ) + ) + / ( + (2.0 + n) + * (3.0 + n) + * (4.0 + n) + * (5.0 + n) + * (6.0 + n) + * (7.0 + n) + ) + + S1 + ) + ) + / (7.0 + n) + + ( + 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 + * ( + -1.0 / np.power(7.0 + n, 5) + + 1.6449340668482262 / np.power(7.0 + n, 3) + - 0.8117424252833533 / (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.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 + ) + ) + / np.power(7.0 + n, 2) + - ( + 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) + ) + / ( + 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 + * ( + ( + -1.6449340668482262 + * ( + 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) + + ( + 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 + * ( + -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) + + ( + (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.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) + ) + ) + / ( + (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) + - ( + 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) + ) + / ( + 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 + * ( + ( + -1.6449340668482262 + * ( + 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) + + ( + 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) + ) + / ( + (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.6449340668482262 + * ( + 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) + - ( + 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) + ) + ) + / ( + 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 + * ( + ( + -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 + ) + ) + / (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 + * ( + -1.0 / np.power(10.0 + n, 5) + + 1.6449340668482262 / np.power(10.0 + n, 3) + - 0.8117424252833533 / (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.6449340668482262 + * ( + 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) + - ( + 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) + ) + ) + / ( + 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) + ) + ) + ) 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..5fee59405 --- /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. + + Parameters + ---------- + 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..f56624f20 --- /dev/null +++ b/src/eko/matching_conditions/n3lo/s_functions.py @@ -0,0 +1,822 @@ +# -*- coding: utf-8 -*- +""" +This module contains some additional harmonics sum. +Defintion are coming from :cite:`MuselliPhD,Bl_mlein_2000,Bl_mlein_2009` +""" +import numpy as np +import numba as nb +import mpmath as mp + +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 binomial(x, y): + 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))) + + +@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 + + +@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 + + +@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 + + +@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 + + +@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 + + +@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): + 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 + - 5 / 8 * zeta3 + + zeta2 * log2 + ) + + +@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) + - 1 / 2 * zeta2 * Sm1 + + 1 / 4 * zeta3 + - 1 / 2 * zeta2 * log2 + ) + + +@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 + - 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): + 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 + + 2 * zeta2 * harmonic_Sm2(N) + + 3 / 40 * zeta2 ** 2 + ) + + +@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 + - li4half + + 1 / 8 * zeta2 ** 2 + + 1 / 8 * zeta3 * log2 + + 1 / 4 * zeta2 * log2 ** 2 + - 1 / 24 * log2 ** 4 + ) + + +@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 + - 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): + 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) + + zeta2 * S21 + - 3 / 10 * zeta2 ** 2 * S1 + ) + + +@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 + - 3 / 10 * zeta2 ** 2 * Sm1 + - 0.119102 + + 0.0251709 + ) + + +@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) + - (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): + 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 + - 0.706186 + + 0.693147 * zeta4 + ) + + +@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 + + 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): + 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) + - 21 / 8 * zeta4 * Sm1 + - 1.32056 + ) 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/src/eko/matching_conditions/operator_matrix_element.py b/src/eko/matching_conditions/operator_matrix_element.py index 19aa3e833..7d6b7019e 100644 --- a/src/eko/matching_conditions/operator_matrix_element.py +++ b/src/eko/matching_conditions/operator_matrix_element.py @@ -6,22 +6,68 @@ 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 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|. @@ -33,6 +79,8 @@ def A_singlet(order, n, sx, 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)` @@ -55,11 +103,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, L) 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| @@ -71,6 +121,8 @@ def A_non_singlet(order, n, sx, 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)` @@ -91,6 +143,8 @@ 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, L) return A_ns @@ -108,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 ------- @@ -124,20 +178,30 @@ 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 @@ -157,10 +221,12 @@ def quad_ker(u, order, mode, is_log, logx, areas, a_s, 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 ""] - 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 @@ -184,12 +250,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: @@ -213,6 +285,99 @@ def quad_ker(u, order, mode, is_log, logx, areas, a_s, 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 point 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|. @@ -234,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"] @@ -256,13 +424,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"]: @@ -271,11 +438,11 @@ 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, L): + def compute(self, q2, nf, L): """ compute the actual operators (i.e. run the integrations) @@ -283,6 +450,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 """ @@ -299,50 +468,77 @@ def compute(self, q2, 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() - 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: - # 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, - 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() diff --git a/src/eko/strong_coupling.py b/src/eko/strong_coupling.py index 859d0b261..78ae29074 100644 --- a/src/eko/strong_coupling.py +++ b/src/eko/strong_coupling.py @@ -128,9 +128,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]: - raise NotImplementedError("a_s beyond NNLO is not implemented") + if order not in [0, 1, 2, 3]: + raise NotImplementedError("a_s beyond N3LO 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_ad_harmonics.py b/tests/test_ad_harmonics.py index 9dc86b78b..b33ccd64c 100644 --- a/tests/test_ad_harmonics.py +++ b/tests/test_ad_harmonics.py @@ -86,8 +86,14 @@ 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_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_f_functions.py b/tests/test_f_functions.py new file mode 100644 index 000000000..a08b5b339 --- /dev/null +++ b/tests/test_f_functions.py @@ -0,0 +1,158 @@ +# -*- coding: utf-8 -*- +# Test F functions implementing w5 harmonics sums + +import numpy as np + +from eko.anomalous_dimensions import harmonics +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 +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, + -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 = sf.harmonic_S41(N, S1, S2, S3) + 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 = sf.harmonic_S311(N, S1, S2) + 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 = sf.harmonic_S221(N, S1, S2, S21) + 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) + S21 = sf.harmonic_S21(N, S1, S2) + Sm21 = sf.harmonic_Sm21(N, Sm1) + Sm221 = sf.harmonic_Sm221(N, S1, 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) + 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 = 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 = sf.harmonic_S2111(N, S1, S2, S3) + 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) + Sm2111 = sf.harmonic_Sm2111(N, S1, S2, S3, Sm1) + np.testing.assert_allclose(Sm2111, 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 new file mode 100644 index 000000000..d0f7f0e7d --- /dev/null +++ b/tests/test_g_functions.py @@ -0,0 +1,92 @@ +# -*- coding: utf-8 -*- +# Test G functions implemented by muselli PhD + +import numpy as np + +from eko.anomalous_dimensions import harmonics +import eko.matching_conditions.n3lo.s_functions as sf + +zeta3 = harmonics.zeta3 +log2 = np.log(2) + + +testN = [1, 10, 100] + + +# 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) + Sm2 = sf.harmonic_Sm2(N) + 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): + 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): + 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) + Sm211 = sf.harmonic_Sm211(N, Sm1) + 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) + 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) + + +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 = sf.harmonic_S211(N, S1, S2, S3) + 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) + 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.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_matching_n3lo.py b/tests/test_matching_n3lo.py new file mode 100644 index 000000000..29c2e817c --- /dev/null +++ b/tests/test_matching_n3lo.py @@ -0,0 +1,257 @@ +# -*- 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 +from eko.matching_conditions import n3lo +from eko.matching_conditions.operator_matrix_element import get_s3x, get_s4x, get_smx + + +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 test_A_3(): + logs = [0, 10] + nf = 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,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, + # ) + + # 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, 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 + # 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, L) + aNS3 = A_ns_3(N, sx_all, nf, L) + 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) + + +def test_Bluemlein_3(): + # 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.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.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 [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, L) + + # 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 + ) + + 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=2e-5, atol=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=2e-4) + + np.testing.assert_allclose( + 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.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, L=0), 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, L=0), r, rtol=1e-5, atol=1e-5 + ) 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 6463d1a3b..e1fded14e 100644 --- a/tests/test_matching_nnlo.py +++ b/tests/test_matching_nnlo.py @@ -75,8 +75,8 @@ 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. + # 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 = { 0: [-9.96091, -30.0093, -36.5914, -40.6765, -43.6823], @@ -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_ome.py b/tests/test_ome.py index 4a33dbe02..ff472421f 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,55 @@ OperatorMatrixElement, build_ome, quad_ker, + run_op_integration, + 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 +75,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 +100,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]) @@ -76,48 +132,53 @@ 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, areas=np.zeros(3), backward_method=None, a_s=0.0, + nf=3, L=0.0, ) 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, areas=np.zeros(3), backward_method=None, a_s=0.0, + nf=3, L=0.0, ) 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, areas=np.zeros(3), backward_method=None, a_s=0.0, + nf=3, L=0.0, ) np.testing.assert_allclose(res_s, 0.0) @@ -127,13 +188,14 @@ 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, areas=np.zeros(3), backward_method="expanded", a_s=0.0, + nf=3, L=0.0, ) if label[-1] == label[-2]: @@ -157,13 +219,14 @@ 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, areas=np.zeros(3), backward_method="exact", a_s=0.0, + nf=3, L=0.0, ) if label[-1] == label[-2]: @@ -174,23 +237,88 @@ 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, 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) +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 = { "alphas": 0.35, - "PTO": 0, + "PTO": 3, "ModEv": "TRN", "fact_to_ren_scale_ratio": 1.0, "Qref": np.sqrt(2), @@ -208,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]: @@ -230,42 +369,62 @@ 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, 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"]: diff --git a/tests/test_s_functions.py b/tests/test_s_functions.py new file mode 100644 index 000000000..74837cfa7 --- /dev/null +++ b/tests/test_s_functions.py @@ -0,0 +1,66 @@ +# -*- coding: utf-8 -*- +# 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 + +# 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) + +def test_binomial(): + r1 = np.random.randint(1000) + r2 = np.random.randint(1000) + np.testing.assert_allclose(sf.binomial(r1,r2), sp.binom(r1, r2)) diff --git a/tests/test_strong_coupling.py b/tests/test_strong_coupling.py index a5897a1ff..b5b930095 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( @@ -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(