ppapp 1.0.0__py3-none-any.whl

ppapp/ppapp.py

@@ -0,0 +1,704 @@
+#!/usr/bin/env python3
+
+"""
+Code generating code for piecewise Chebyshev approximation
+
+Reference: Joachim Wuttke and Alexander Kleinsorge,
+           Algorithm 1XXX: Code generation for piecewise Chebyshev approximation
+
+File:      ppapp/ppapp.py
+
+Main program that prints polynomial coefficients in different formats.
+These coefficients pertain to a piecewise Chebyshev approximation of a function f.
+A high-precision reference implementation of function f must be provided in reference_f.py.
+
+Usage of the generated file is demonstrated in directory src/dem.
+
+License:   GNU General Public License, version 3 or higher (see src/LICENSE)
+Copyright: Forschungszentrum Jülich GmbH 2025
+Author:    Joachim Wuttke <j.wuttke@fz-juelich.de>
+"""
+
+import os
+import sys
+from math import frexp, isfinite, log
+from sys import argv, stderr
+from time import ctime, localtime, strftime, time
+
+# Import high-precision Chebyshev coefficient computation
+try:
+    from ppapp.cheb_coeffs import cheb_cn, cheb_pm, check_coeffs, ref_f, set_reference_function
+except ModuleNotFoundError:
+    print("Error: Cannot import ppapp.cheb_coeffs.", file=sys.stderr)
+    print("", file=sys.stderr)
+    print("Run from the directory containing the 'ppapp' package:", file=sys.stderr)
+    print("  cd /path/to/py/R", file=sys.stderr)
+    print("  python -m ppapp <mode> <args>", file=sys.stderr)
+    print("", file=sys.stderr)
+    print("Or install via pip and run from anywhere:", file=sys.stderr)
+    print("  ppapp <mode> <args>", file=sys.stderr)
+    sys.exit(1)
+
+
+# Subdomain class definition
+class Subdomain:
+    """
+    Represents a subdomain for piecewise approximation.
+    """
+
+    def __init__(self, j=0, i=0, a=0.0, b=0.0):
+        self.j = j  # octave index
+        self.i = i  # subdomain index within octave
+        self.a = a  # lower bound
+        self.b = b  # upper bound
+        self.coeffs = []  # polynomial coefficients
+        self.s = 0.0  # power law parameter
+        self.r = 0.0  # power law parameter
+
+
+# Power law analysis
+def analyse_row(coeffs: list[float]) -> tuple[float, float]:
+    """
+    Returns parameters s,r of power law h(n)=s*r^n that approximates |coeffs[n]|
+    while |coeffs[n]| <= h(n).
+
+    Solution is by brute force, considering all power laws that touch a pair of data points.
+
+    This matches the C++ implementation in power_law.cpp.
+
+    Args:
+        coeffs: List of polynomial coefficients
+
+    Returns:
+        Tuple (s, r) where s*r^n bounds the coefficient magnitudes
+    """
+    assert len(coeffs) >= 2
+
+    # Take absolute values
+    y = [abs(v) for v in coeffs]
+    N = len(y) - 1
+
+    # Power-law model: h(n) = s * r^n
+    def make_model(y_vals, i, j):
+        """Create power law model that passes through y[i] and y[j]."""
+        assert 0 <= i < j < len(y_vals)
+        assert y_vals[i] > 0
+        r = (y_vals[j] / y_vals[i]) ** (1.0 / (j - i))
+        s = y_vals[i] * (r ** -i)
+        return s, r
+
+    def model_f(s, r, i):
+        """Evaluate model at index i."""
+        return s * (r ** i)
+
+    def least_squares(s, r, y_vals):
+        """Compute sum of squared log deviations."""
+        result = 0.0
+        for k in range(len(y_vals)):
+            assert y_vals[k] > 0
+            result += log(y_vals[k] / model_f(s, r, k)) ** 2
+        return result
+
+    # Initial solution: endpoints
+    solution_s, solution_r = make_model(y, 0, N)
+    squares = float('inf')
+
+    for i in range(N - 1):
+        for j in range(i + 1, N):
+            s, r = make_model(y, i, j)
+
+            # Check that this model bounds all data points
+            valid = True
+            for k in range(N):
+                if y[k] > model_f(s, r, k) * (1 + 1e-13):
+                    valid = False
+                    break
+
+            if not valid:
+                continue
+
+            sq = least_squares(s, r, y)
+            if sq < squares:
+                squares = sq
+                solution_s, solution_r = s, r
+
+    if not isfinite(squares):
+        for i in range(N - 1):
+            print(f"y[{i}] = {coeffs[i]}")
+        raise RuntimeError("fit failed: squares=infty")
+
+    return solution_s, solution_r
+
+
+# Error estimation
+def error_bound(d: Subdomain, N: int) -> float:
+    """
+    Returns maximum relative error, computed from coefficients and power-law parameters provided by d.
+    Implements Eq (46) of Wuttke and Kleinsorge, "Code generation for piecewise Chebyshev approximation".
+
+    Args:
+        d: Subdomain with computed coefficients, s, and r values
+        N: Polynomial degree
+
+    Returns:
+        Error bound in units of machine epsilon
+    """
+    assert len(d.coeffs) > N
+
+    p0 = d.coeffs[0]
+    denom = p0 - d.s * (d.r ** (N + 1)) / (1 - d.r)
+
+    re = 2 * p0
+    for n in range(1, N + 1):
+        denom -= abs(d.coeffs[n])
+        re += (3 + n) * abs(d.coeffs[n])
+
+    eps = 2.0 ** -53
+    te = d.s * (d.r ** (N + 1)) / (1 - d.r) / eps
+
+    assert denom > 0, f"denom={denom} must be positive"
+    return (re + te) / denom
+
+
+# Subdomain computation
+def compute_subdomains(a: float, b: float, M: int) -> tuple[int, int, list[Subdomain]]:
+    """
+    Divide the interval [a, b] into 2^M subdomains per octave.
+
+    This matches the C++ implementation in subdomain.cpp.
+
+    Args:
+        a: Lower bound of domain
+        b: Upper bound of domain
+        M: Number of subdivisions per octave (2^M subdomains per octave)
+
+    Returns:
+        Tuple (j0, l0, D) where:
+        - j0 is the exponent for frexp(a) (first octave starts at 2^(j0-1))
+        - l0 is the starting subdomain index in first octave
+        - D is the list of Subdomain objects
+    """
+    assert a < b, "Lower bound must be less than upper bound"
+    assert M >= 0, "M must be non-negative"
+
+    ni = 1 << M  # 2^M subdomains per octave
+
+    # Use frexp to get exponents (like C++ implementation)
+    # frexp returns (mantissa, exponent) where a = mantissa * 2^exponent
+    # and mantissa is in [0.5, 1.0)
+    _, ea = frexp(a)
+    _, eb = frexp(b)
+
+    D = []
+    result_l0 = -1
+
+    for j in range(ea - 1, eb):
+        for i in range(ni):
+            asu = (ni + i) * (2.0 ** (j - M))
+            bsu = asu + (2.0 ** (j - M))
+            if bsu > a and asu < b:
+                # Store j relative to ea (like C++ does: j - ea + 1)
+                d = Subdomain(j - ea + 1, i, asu, bsu)
+                D.append(d)
+                if result_l0 == -1:
+                    result_l0 = i
+
+    return ea, result_l0, D
+
+
+# Output functions
+def hexfloat(x: float) -> str:
+    """
+    Returns hexadecimal floating-point representation of x.
+    Result looks like -0x1.8....p-27.
+    This is in decimal notation -1.5.... * 2^(-27).
+    Note that binary exponent (following 'p') is rendered as a decimal number.
+    """
+    if x >= 0:
+        return x.hex()
+    else:
+        # Python's hex() already handles negative numbers, but we want consistent format
+        return "-" + (-x).hex()
+
+
+def n_output_coeffs(N: int) -> int:
+    """
+    Returns number of polynomial coefficients per subdomain that are written to the C tables.
+    For given polynomial degree N, this is normally N+1.
+    However, for alignment reasons as described in Sect 2.3 of the reference paper,
+    for certain N we fill up with zeroes.
+    """
+    assert N >= 0
+    remainder = (N + 1) % 8
+    if remainder in (0, 1, 2, 4):
+        return N + 1
+    elif remainder == 3:
+        return N + 2  # fill up to 4
+    else:
+        return ((N + 1) // 8 + 1) * 8  # fill up to 8
+
+
+def print_table(start_time: float, output_c: bool, a: float, b: float, M: int, N: int,
+                j0: int, l0: int, D: list[Subdomain]) -> None:
+    """
+    Print plain table of coefficients.
+
+    Args:
+        start_time: Time when program started
+        output_c: If True, print Chebyshev coefficients c_n, else power coefficients p_m
+        a: Lower domain bound
+        b: Upper domain bound
+        M: Subdivision parameter
+        N: Polynomial degree
+        j0: Starting octave index
+        l0: Number of octaves
+        D: List of subdomains
+    """
+    # Print header comment
+    coeff_type = "c_n" if output_c else "p_m"
+    print(f"# Table of {'Chebyshev' if output_c else 'economized'} coefficients {coeff_type}")
+    print(f"# Generated: {ctime(start_time)}")
+    print(f"# Domain: [{a}, {b})")
+    print(f"# M={M}, N={N}, j0={j0}, l0={l0}")
+    print(f"# Number of subdomains: {len(D)}")
+    print("#")
+    print("# Format: j i a b coeff[0] coeff[1] ... coeff[N]")
+    print("#")
+
+    for d in D:
+        print(f"{d.j} {d.i} {d.a:.16e} {d.b:.16e}", end="")
+        for coeff in d.coeffs:
+            print(f" {coeff:.16e}", end="")
+        print()
+
+
+def print_source(start_time: float, a: float, b: float, M: int, N: int,
+                 j0: int, l0: int, D: list[Subdomain]) -> None:
+    """
+    Print C source code defining economized coefficients.
+
+    Args:
+        start_time: Time when program started
+        a: Lower domain bound
+        b: Upper domain bound
+        M: Subdivision parameter
+        N: Polynomial degree
+        j0: Starting octave index
+        l0: Number of octaves
+        D: List of subdomains
+    """
+    # Derived parameters
+    Nout = n_output_coeffs(N)
+    assert Nout > N
+    nTables = (Nout - 1) // 8 + 1
+    assert nTables >= 1
+    nr = len(D)
+
+    # Write top lines to file
+    print("//--- Begin of auto-generated code; do not edit")
+    print("//")
+    print(f"// Generated on {strftime('%Y-%m-%d, %H:%M:%S', localtime(start_time))}")
+    print("// by the piecewise polynomial approximation generator (https://jugit.fz-juelich.de/mlz/ppapp)")
+    print("// Reference: Wuttke and Kleinsorge,")
+    print('//            "Code generation for piecewise Chebyshev approximation."')
+    print("//")
+    print("// clang-format off")
+    # Format a and b to avoid unnecessary .0 suffix
+    a_str = str(int(a)) if a == int(a) else str(a)
+    b_str = str(int(b)) if b == int(b) else str(b)
+    print(f"static const double ppapp_a = {a_str}; // begin of domain")
+    print(f"static const double ppapp_b = {b_str}; // end of domain")
+    print(f"static const int ppapp_M = {M}; // 2^M subdomains per octave")
+    print(f"static const int ppapp_N = {N}; // polynomial degree")
+    print(f"static const int ppapp_nr = {nr}; // total number of subdomains")
+    print(f"static const int ppapp_j0 = {j0}; // first octave starts at 2^(j0−1)")
+    print(f"static const int ppapp_l0 = {l0}; // index of a in first octave")
+    print(f"static const int ppapp_Nout = {Nout}; // stored coeffs per subdomain")
+    print(f"static const int ppapp_nTables = {nTables};")
+
+    # Write coefficient tables to file
+    for k in range(nTables):
+        print()
+        print(f"alignas(64) static const double ppapp_Coeffs{k}[{nr} * {min(8, Nout - k*8)}] = {{")
+        for d in D:
+            print("    ", end="")
+            for n in range(k * 8, min(Nout, (k + 1) * 8)):
+                if N - n < 0:
+                    print("0", end="")
+                else:
+                    print(hexfloat(d.coeffs[N - n]), end="")
+                print(", ", end="")
+            print(f"// subdomain {d.j}:{d.i} ({d.a}..{d.b})")
+        print("};")
+
+    # Write bottom lines to file
+    print("// clang-format on")
+    print("//--- End of auto-generated code")
+
+
+def print_testcases(start_time: float, a: float, b: float, M: int, Nxo: int,
+                    D: list[Subdomain], relerr: float) -> None:
+    """
+    Print C source code defining test cases.
+
+    Args:
+        start_time: Time when program started
+        a: Lower domain bound
+        b: Upper domain bound
+        M: Subdivision parameter
+        Nxo: Number of extra octaves
+        D: List of subdomains (extended domain)
+        relerr: Maximum relative error
+    """
+    print("/*")
+    print(" * Test cases for Chebyshev approximation")
+    print(f" * Generated: {ctime(start_time)}")
+    print(f" * Domain: [{a}, {b})")
+    print(f" * M={M}, Nxo={Nxo}, relerr={relerr}")
+    print(f" * Extended domain includes {Nxo} extra octaves on each side")
+    print(" */")
+    print()
+    print("typedef struct {")
+    print("    double x;")
+    print("    double f_ref;")
+    print("} test_case_t;")
+    print()
+
+    # Generate test points
+    test_points = []
+    for d in D:
+        # Test at subdomain boundaries and midpoint
+        for frac in [0.0, 0.25, 0.5, 0.75, 1.0]:
+            x = d.a + frac * (d.b - d.a)
+            try:
+                f_val = ref_f(x)
+                test_points.append((x, f_val))
+            except Exception:
+                pass
+
+    print("static const test_case_t test_cases[] = {")
+    for i, (x, f_val) in enumerate(test_points):
+        comma = "," if i < len(test_points) - 1 else ""
+        print(f"    {{{x:.16e}, {f_val:.16e}}}{comma}")
+    print("};")
+    print()
+    print(f"#define NUM_TEST_CASES {len(test_points)}")
+
+
+# Helper function for parallel processing
+def compute_subdomain_coeffs_for_nmin(args):
+    """Helper function for parallel computation of N_min."""
+    k, d_data, M, N, relerr, output_c = args
+    d = Subdomain(d_data['j'], d_data['i'], d_data['a'], d_data['b'])
+
+    for n in range(2, N + 1):
+        try:
+            d.coeffs = cheb_cn(d.a, d.b, n) if output_c else cheb_pm(d.a, d.b, n)
+            assert len(d.coeffs) == n + 1
+
+            d.s, d.r = analyse_row(d.coeffs)
+            r = error_bound(d, n)
+
+            if r <= relerr:
+                return (k, n)
+        except Exception as ex:
+            print(f"# M = {M}")
+            print(f"# n = {n}")
+            print(f"# domain = [{d.a}, {d.b})")
+            print(f"# {ex}")
+
+    return (k, 0)
+
+
+def compute_subdomain_coeffs(args):
+    """Helper function for parallel computation of coefficients."""
+    k, d_data, N, output_c = args
+    d = Subdomain(d_data['j'], d_data['i'], d_data['a'], d_data['b'])
+
+    d.coeffs = cheb_cn(d.a, d.b, N) if output_c else cheb_pm(d.a, d.b, N)
+    assert len(d.coeffs) == N + 1
+
+    d.s, d.r = analyse_row(d.coeffs)
+    err = error_bound(d, N)
+
+    return (k, {'j': d.j, 'i': d.i, 'a': d.a, 'b': d.b, 'coeffs': d.coeffs, 's': d.s, 'r': d.r}, err)
+
+
+# Function module loading
+def load_function_module(module_path):
+    """
+    Dynamically load a function definition file.
+
+    Args:
+        module_path: File path (e.g., 'f_imwofx.py' or 'path/to/f_custom.py')
+
+    Returns:
+        The loaded module object
+    """
+    import importlib.util
+
+    if not module_path.endswith('.py'):
+        module_path = module_path + '.py'
+
+    if not os.path.isabs(module_path):
+        module_path = os.path.abspath(module_path)
+
+    if not os.path.exists(module_path):
+        print(f"Error: Function definition file not found: {module_path}", file=stderr)
+        exit(1)
+
+    module_name = os.path.splitext(os.path.basename(module_path))[0]
+
+    spec = importlib.util.spec_from_file_location(module_name, module_path)
+    if spec is None or spec.loader is None:
+        print(f"Error: Cannot load module from: {module_path}", file=stderr)
+        exit(1)
+
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    # Validate that required attributes exist
+    if not hasattr(module, 'my_arb_f'):
+        print(f"Error: Module {module_spec} does not define 'my_arb_f'", file=stderr)
+        exit(1)
+    if not hasattr(module, 'my_domain'):
+        print(f"Error: Module {module_spec} does not define 'my_domain'", file=stderr)
+        exit(1)
+    if not hasattr(module, 'my_testcases'):
+        print(f"Error: Module {module_spec} does not define 'my_testcases'", file=stderr)
+        exit(1)
+
+    return module
+
+
+# Help function
+def help_and_exit():
+    """Prints help and terminates program."""
+    print("Usage:\n")
+    print("ppapp i <f_module>                     - run initial tests from my_testcases")
+    print("ppapp v <f_module> <x>                 - print function value f(x)")
+    print("ppapp n <f_module> <M> <Nmax> <E>      - print N_min(M',E), up to given Nmax")
+    print("ppapp e <f_module> <M> <N>             - print maximum relative error, in units of epsilon")
+    print("ppapp c <f_module> <M> <N> [<E>]       - print plain table of Chebyshev coefficients c_n")
+    print("ppapp p <f_module> <M> <N> [<E>]       - print plain table of economized coefficients p_m")
+    print("ppapp s <f_module> <M> <N> [<E>]       - print C source defining economized coefficients p_m")
+    print("ppapp t <f_module> <M> <Nxo> <E>       - print C source defining test cases")
+    print("\nwhere\n")
+    print("<f_module> - path to function definition file (e.g., 'mydir/f_imwofx.py')")
+    print("<M>        - integer M >= 0 specifies 2^M subdomains per octave")
+    print("<N>        - integer N >= 1 is the polynomial degree")
+    print("<E>        - double E > 0 is the maximum relative error, in units of epsilon=2^-53")
+    print("<Nxo>      - number of extra (non-Chebyshev) octaves on each side of the Chebyshev range")
+    exit(1)
+
+
+# Main function
+def main():
+    """
+    Computes and prints polynomial coefficients that approximate function ref_f.
+    """
+    start_time = time()  # needed for comment line in output
+
+    # Process command-line arguments
+    if len(argv) < 2:
+        print("No mode given\n", file=stderr)
+        help_and_exit()
+
+    mode = argv[1][0]
+
+    # Handle help mode first
+    if mode == 'h':
+        help_and_exit()
+
+    if len(argv) < 3:
+        print("No function module given\n", file=stderr)
+        help_and_exit()
+
+    output_c = False
+    allow_E = True
+    request_E = False
+
+    # Determine mode characteristics
+    if mode == 'c':
+        output_c = True
+    elif mode == 'e':
+        allow_E = False
+    elif mode in ['n', 't']:
+        request_E = True
+    elif mode in ['p', 's']:
+        pass
+    elif mode == 'i':
+        # Special case: mode 'i' only requires f_module
+        if len(argv) != 3:
+            print("Wrong number of arguments\n", file=stderr)
+            help_and_exit()
+
+        # Load function module
+        f_module = load_function_module(argv[2])
+        set_reference_function(f_module.my_arb_f)
+
+        # Run tests from my_testcases
+        failed = 0
+        for x, f_expected, tol in f_module.my_testcases:
+            f_val = ref_f(x)
+            rel_err = abs((f_val - f_expected) / f_expected)
+            if rel_err > tol:
+                print(f"FAIL: x={x}: expected {f_expected}, got {f_val}, rel_err={rel_err}, tol={tol}")
+                failed += 1
+            else:
+                print(f"PASS: x={x}: f={f_val}, rel_err={rel_err:.2e} <= {tol}")
+
+        if failed:
+            print(f"\n{failed} test(s) failed")
+            return 1
+        print(f"\nAll {len(f_module.my_testcases)} tests passed")
+        return 0
+    elif mode == 'v':
+        # Special case: mode 'v' has different argument structure
+        if len(argv) != 4:
+            print("Wrong number of arguments\n", file=stderr)
+            help_and_exit()
+
+        # Load function module
+        f_module = load_function_module(argv[2])
+        set_reference_function(f_module.my_arb_f)
+
+        try:
+            x = float(argv[3])
+        except ValueError:
+            print(f"Invalid argument x: {argv[3]}\n", file=stderr)
+            help_and_exit()
+
+        print(f"{x:.16e} {ref_f(x):.16e}")
+        return 0
+    else:
+        print("Invalid mode\n", file=stderr)
+        help_and_exit()
+
+    # Load function module (for all modes except 'v' which already loaded it)
+    f_module = load_function_module(argv[2])
+    set_reference_function(f_module.my_arb_f)
+
+    min_args = 5 + (1 if request_E else 0)
+    max_args = 5 + (1 if allow_E else 0)
+
+    if len(argv) < min_args or len(argv) > max_args:
+        print("Wrong number of arguments\n", file=stderr)
+        help_and_exit()
+
+    # Parse M
+    try:
+        M = int(argv[3])
+        if M < 0:
+            raise ValueError
+    except ValueError:
+        print(f"Invalid M={argv[3]}\n", file=stderr)
+        help_and_exit()
+
+    # Parse N
+    try:
+        N = int(argv[4])
+        if N < 1:
+            raise ValueError
+    except ValueError:
+        print(f"Invalid N={argv[4]}\n", file=stderr)
+        help_and_exit()
+
+    # Parse relerr if present
+    relerr = 0.0
+    if len(argv) == 6:
+        try:
+            relerr = float(argv[5])
+            if not isfinite(relerr) or relerr <= 0:
+                raise ValueError
+        except ValueError:
+            print(f"Invalid rel_err: {argv[5]}\n", file=stderr)
+            help_and_exit()
+
+    # Take domain limits from loaded module and check
+    a, b = f_module.my_domain
+    assert a > 0, "Lower domain bound must be positive"
+    assert b > a, "Upper domain bound must be greater than lower bound"
+
+    j0 = 0
+    l0 = 0
+    D = []
+
+    # Determine N_min for M
+    if mode == 'n':
+        assert relerr > 0.0
+        j0, l0, D = compute_subdomains(a, b, M)
+        Nmin = [0] * len(D)
+
+        # Parallel computation using multiprocessing
+        # Note: Using sequential computation for simplicity and compatibility
+        # OpenMP-style parallelization can be achieved with multiprocessing.Pool
+        for k, d in enumerate(D):
+            # print(f"j,i={d.j},{d.i} a,b={d.a},{d.b}:")
+            for n in range(2, N + 1):
+                d.coeffs = cheb_pm(d.a, d.b, n)
+                assert len(d.coeffs) == n + 1
+                try:
+                    d.s, d.r = analyse_row(d.coeffs)
+                    r = error_bound(d, n)
+                    # print(f"# n={n} r={r}")
+                    if r <= relerr:
+                        Nmin[k] = n
+                        break
+                except Exception as ex:
+                    print(f"# M = {M}")
+                    print(f"# n = {n}")
+                    print(f"# domain = [{a}, {b})")
+                    print(f"# {ex}")
+
+        print("# Per subdomain: j i a b Nmin:")
+        for k, d in enumerate(D):
+            print(f"{d.j} {d.i} {d.a} {d.b} {Nmin[k]}")
+
+        print(f"# Total N_min: {max(Nmin)}")
+        return 0
+
+    # Compute polynomial coefficients
+    if mode == 't':
+        j0, l0, D = compute_subdomains(a / (2 ** N), b * (2 ** N), M)
+        print_testcases(start_time, a, b, M, N, D, relerr)
+        return 0
+
+    j0, l0, D = compute_subdomains(a, b, M)
+    Err = [0.0] * len(D)
+
+    # Parallel computation (sequential for compatibility)
+    for k, d in enumerate(D):
+        d.coeffs = cheb_cn(d.a, d.b, N) if output_c else cheb_pm(d.a, d.b, N)
+        assert len(d.coeffs) == N + 1
+        d.s, d.r = analyse_row(d.coeffs)
+        Err[k] = error_bound(d, N)
+
+    # Calculate maximum error
+    err = max(Err)
+
+    if mode == 'e':
+        print(f"Maximum error bound: {err} epsilon")
+        return 0
+    elif relerr and err > relerr:
+        print(f"Maximum error bound: {err} larger than given bound", file=stderr)
+        return 1
+
+    # Print results
+    if mode == 's':
+        assert not output_c
+        if relerr:
+            for d in D:
+                for t in [-1., -.99897969, -.7924, -.5, 0., 1e-8, .25, .9987654321, 1.]:
+                    check_coeffs(d.a, d.b, d.coeffs, t, relerr)
+        print_source(start_time, a, b, M, N, j0, l0, D)
+    elif mode in ('c', 'p'):
+        print_table(start_time, output_c, a, b, M, N, j0, l0, D)
+    else:
+        raise AssertionError("Invalid mode")
+
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())