ppapp 1.0.0__py3-none-any.whl

ppapp/target_algorithm.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+
+"""
+Target algorithm for piecewise polynomial evaluation.
+
+This script demonstrates the algorithm that evaluates a piecewise polynomial
+approximation using Horner's method. It shows how to:
+- Find the subdomain containing a given x
+- Transform x to the local coordinate t in [-1, 1]
+- Evaluate the polynomial using Horner's method
+
+IMPORTANT: This plain Python implementation is for illustration only.
+Project ppapp is designed to generate C code for optimized high-throughput
+computation. For production use from Python, the evaluation code should be
+implemented as a C extension module or at least use NumPy for vectorized
+operations. Do not use this script as a template for production code.
+
+Run with:
+    python -m ppapp.target_algorithm
+"""
+
+from ppapp import cheb_pm, compute_subdomains, ref_f, set_reference_function
+from ppapp.demo_functions.imwofx import my_arb_f, my_domain
+
+
+def find_subdomain(x: float, subdomains) -> int:
+    """Find the subdomain index containing x."""
+    for i, d in enumerate(subdomains):
+        if d.a <= x < d.b:
+            return i
+    # x might equal the last boundary
+    if subdomains and x == subdomains[-1].b:
+        return len(subdomains) - 1
+    raise ValueError(f"x={x} not in any subdomain")
+
+
+def horner_eval(coeffs: list[float], t: float) -> float:
+    """Evaluate polynomial using Horner's method."""
+    result = coeffs[-1]
+    for c in reversed(coeffs[:-1]):
+        result = result * t + c
+    return result
+
+
+def main():
+    # Set up
+    set_reference_function(my_arb_f)
+    a, b = my_domain
+    M = 5
+    N = 10
+
+    # Compute subdomains and their coefficients
+    j0, l0, subdomains = compute_subdomains(a, b, M)
+    for d in subdomains:
+        d.coeffs = cheb_pm(d.a, d.b, N)
+
+    # Test points
+    test_x = [0.5, 1.0, 2.0, 5.0, 10.0, 11.9]
+
+    print("Comparing approximation vs reference:")
+    print("-" * 70)
+    print(f"{'x':>10} {'f_approx':>20} {'f_ref':>20} {'rel_error':>15}")
+    print("-" * 70)
+
+    eps = 2.0 ** -53  # Machine epsilon
+
+    for x in test_x:
+        # Find subdomain
+        idx = find_subdomain(x, subdomains)
+        d = subdomains[idx]
+
+        # Transform x to [-1, 1]
+        mid = (d.a + d.b) / 2
+        half = (d.b - d.a) / 2
+        t = (x - mid) / half
+
+        # Evaluate approximation
+        f_approx = horner_eval(d.coeffs, t)
+
+        # Evaluate reference
+        f_ref = ref_f(x)
+
+        # Relative error in units of epsilon
+        rel_err = abs(f_approx - f_ref) / abs(f_ref) / eps
+
+        print(f"{x:10.4f} {f_approx:20.15f} {f_ref:20.15f} {rel_err:12.2f} eps")
+
+
+if __name__ == "__main__":
+    main()

ppapp-1.0.0.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: ppapp
+Version: 1.0.0
+Summary: Piecewise polynomial approximation: code generator for Chebyshev approximation
+Author-email: Joachim Wuttke <j.wuttke@fz-juelich.de>, Alexander Kleinsorge <alkl9873@th-wildau.de>
+License: GPL-3.0-or-later
+Project-URL: Repository, https://jugit.fz-juelich.de/mlz/ppapp
+Project-URL: Documentation, https://jugit.fz-juelich.de/mlz/ppapp/-/blob/main/py/R/userManual/userManual.pdf
+Keywords: chebyshev,approximation,polynomial,code-generation,numerical
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-flint>=0.4.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Dynamic: license-file
+
+# ppapp - Piecewise Polynomial Approximation
+
+Code generator for piecewise Chebyshev approximation of mathematical functions.
+
+## Overview
+
+This package generates C source code containing polynomial coefficients that approximate
+a given function f(x) over a specified domain. The approximation uses piecewise Chebyshev
+polynomials with octave-based domain subdivision for optimal accuracy.
+
+**Reference:** Joachim Wuttke and Alexander Kleinsorge,
+"Algorithm 1XXX: Code generation for piecewise Chebyshev approximation"
+
+## Installation
+
+```bash
+pip install ppapp
+```
+
+### Requirements
+
+- Python 3.9+
+- python-flint (for arbitrary-precision arithmetic)
+
+## Quick Start
+
+### Command Line
+
+```bash
+# Compute a function value
+ppapp v ppapp.demo_functions.imwofx 1.0
+
+# Compute error bound for given M and N
+ppapp e ppapp.demo_functions.imwofx 5 10
+
+# Generate C source code
+ppapp s ppapp.demo_functions.imwofx 5 10 > coefficients.c
+```
+
+### Using Demo Functions
+
+The package includes several demo functions:
+
+```bash
+# Im w(x) = exp(-x^2) * erfi(x)
+ppapp e ppapp.demo_functions.imwofx 5 10
+
+# erfcx(x) = exp(x^2) * erfc(x)
+ppapp e ppapp.demo_functions.erfcx 5 10
+
+# Polynomial x^3 - x^2 + x - 1
+ppapp e ppapp.demo_functions.polynomial 8 15
+```
+
+### Python API
+
+```python
+from ppapp import (
+    set_reference_function,
+    compute_subdomains,
+    cheb_pm,
+    analyse_row,
+    error_bound,
+)
+from ppapp.demo_functions.imwofx import my_arb_f, my_domain
+
+# Set the reference function
+set_reference_function(my_arb_f)
+
+# Compute subdomains
+a, b = my_domain
+j0, l0, D = compute_subdomains(a, b, M=5)
+
+# Compute coefficients for each subdomain
+for d in D:
+    d.coeffs = cheb_pm(d.a, d.b, N=10)
+    d.s, d.r = analyse_row(d.coeffs)
+    err = error_bound(d, N=10)
+    print(f"Subdomain [{d.a}, {d.b}): error = {err:.2f} epsilon")
+```
+
+## Creating Custom Functions
+
+Create a Python module with:
+
+```python
+from flint import arb
+
+# Domain [a, b)
+my_domain: tuple[float, float] = (0.5, 12.0)
+
+def my_arb_f(X: arb, prec: int) -> arb:
+    """Evaluate f(x) with given precision."""
+    # Your implementation here
+    return result
+
+# Test cases: (x, expected_value, tolerance)
+my_testcases: list[tuple[float, float, float]] = [
+    (1.0, 0.123456, 1e-5),
+]
+```
+
+Then use it:
+
+```bash
+ppapp s path/to/my_function.py 5 10 > output.c
+```
+
+## Modes
+
+| Mode | Command | Description |
+|------|---------|-------------|
+| v | `ppapp v <f> <x>` | Compute f(x) |
+| n | `ppapp n <f> <M> <Nmax> <E>` | Find minimal N for error ≤ E |
+| e | `ppapp e <f> <M> <N>` | Compute error bound |
+| c | `ppapp c <f> <M> <N> [E]` | Print Chebyshev coefficients |
+| p | `ppapp p <f> <M> <N> [E]` | Print monomial coefficients |
+| s | `ppapp s <f> <M> <N> [E]` | Generate C source code |
+| t | `ppapp t <f> <M> <Nxo> <E>` | Generate test cases |
+
+## Documentation
+
+The user manual is included in the package:
+
+```python
+from ppapp import get_user_manual_path
+print(get_user_manual_path())  # Path to userManual.pdf
+```
+
+## License
+
+GNU General Public License v3 or later (GPLv3+)
+
+## Authors
+
+- Joachim Wuttke (Forschungszentrum Jülich GmbH)
+- Alexander Kleinsorge (Technische Hochschule Wildau)
+
+## Links
+
+- [Repository](https://jugit.fz-juelich.de/mlz/ppapp)
+- [Documentation (PDF)](https://jugit.fz-juelich.de/mlz/ppapp/-/blob/main/py/R/userManual/userManual.pdf)

ppapp-1.0.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+ppapp/__init__.py,sha256=T7WZdoCZI-ljRhojl-LCU_fmZ_6RJYr0zmSrg95XEB4,1280
+ppapp/__main__.py,sha256=sptjNoySx17mJRZRJ_XBm0vX33DSTZRP4ogZFs-hYx4,140
+ppapp/cheb_coeffs.py,sha256=PztuebJNdy4fQ4GKQou5I71zf73L98m_nfAglNK7ZhM,8699
+ppapp/ppapp.py,sha256=02AzT_fpwF5t0ieEs4SryzmrCXtmytP1dnu8H8QdeqI,23293
+ppapp/target_algorithm.py,sha256=msgZuKdsQgj0cKKaV9RhtYVn274c5KdVsw7LA3TlLAY,2635
+ppapp/demo_functions/__init__.py,sha256=M0EiyXtb05zYNFB6YQJlANJyE0AcBrILhqpddExM2aI,666
+ppapp/demo_functions/erfcx.py,sha256=cZbLzJBMGBmNDOtspsdHKX8qrLrtvAYpYg8KUzfY37w,1305
+ppapp/demo_functions/imwofx.py,sha256=_0ApFx5P189URwEHb1lLrk19sh1gL24iJFEPDUvO8V4,1298
+ppapp/demo_functions/polynomial.py,sha256=UOEZ-y4r_No9epyppHmjBzZA_x4THBdaxp_lf6b_-Z8,1496
+ppapp/demo_functions/voigt_hwhm.py,sha256=ulJimr32u8ZvUH_b_ROt9VUPZwbFQFJ7WHF1F3fCM0Y,3727
+ppapp/docs/userManual.pdf,sha256=wxD14KR37Wuff8IBHc7WfHouHfr2A6fhdfKFqq3QHaA,91907
+ppapp-1.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+tests/__init__.py,sha256=I4m6tknsJyCzmLgbzdxpLwvJYdddqPAMZ0erGxkVfX8,31
+tests/test_app.py,sha256=p-itnDWkWPo97OAZCxCdryJcjExEZjJXuWPIHI3FsEo,13084
+userManual/userManual.pdf,sha256=wxD14KR37Wuff8IBHc7WfHouHfr2A6fhdfKFqq3QHaA,91907
+userManual/userManual.tex,sha256=1ntNVjg7mSfFnciEmVIavW7xNQ1Lb1JyZBldTEwdaaY,15397
+ppapp-1.0.0.dist-info/METADATA,sha256=1_-7bLeEPNfpYnU9M_mPknHjC-7rgT_Mmh7P4C4jlEs,4673
+ppapp-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ppapp-1.0.0.dist-info/entry_points.txt,sha256=xlSmZvp-e8xavDq6PRnOv_YMpbyjM0XUSaWL-pzttO4,43
+ppapp-1.0.0.dist-info/top_level.txt,sha256=F1MZGl78sIGn8l3Ykfs6ruNnYQPiC4_vJkgkif90aTI,23
+ppapp-1.0.0.dist-info/RECORD,,

ppapp-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ppapp-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ppapp = ppapp.ppapp:main