Minterpy: Multivariate Polynomial Interpolation in Python

Branches	Status
main (stable)
dev (latest)

Minterpy is an open-source Python package designed for constructing and manipulating multivariate interpolating polynomials with the goal of lifting the curse of dimensionality from interpolation tasks.

Minterpy is being continuously extended and improved, with new functionalities added to address the bottlenecks involving interpolations in various computational tasks.

Installation

You can obtain the stable release of Minterpy directly from PyPI using pip:

pip install minterpy

Alternatively, you can also obtain the latest version of Minterpy from the GitHub repository:

git clone https://github.com/minterpy-project/minterpy

Then from the source directory, you can install Minterpy:

pip install [-e] .[all,dev,docs]

where the flag -e means the package is directly linked into the python site-packages of your Python version. The options [all,dev,docs] refer to the requirements defined in the options.extras_require section in setup.cfg.

A best practice is to first create a virtual environment with the help of a tool like mamba, conda, venv, virtualenv or pyenv-virtualenv. See CONTRIBUTING.md for details.

NOTE: Do not use the command python setup.py install to install Minterpy, as we cannot guarantee that the file setup.py will always be present in the further development of Minterpy.

Quickstart

Using Minterpy, you can easily interpolate a given function. For instance, take the one-dimensional function $f(x) = x \, \sin{(10x)}$ with $x \in [-1, 1]$:

import numpy as np

def test_function(x):
    return x * np.sin(10*x)

To interpolate the function, you can use the top-level function interpolate():

import minterpy as mp

interpolant = mp.interpolate(test_function, spatial_dimension=1, poly_degree=64)

interpolate() takes as arguments the function to interpolate, the number of dimensions (spatial_dimension), and the degree of the underlying polynomial interpolant (poly_degree). You may adjust this parameter in order to get higher accuracy. The resulting interpolant is a Python callable, which can be used as an approximation of test_function.

In this example, an interpolating polynomial of degree $64$ produces an approximation of test_function to near machine precision:

import matplotlib.pyplot as plt

xx = np.linspace(-1, 1, 150)

plt.plot(xx, interpolant(xx), label="interpolant")
plt.plot(xx, test_function(xx), "k.",label="test function")
plt.legend()
plt.show()

Minterpy's capabilities extend beyond function approximation; by accessing the underlying interpolating polynomials, you can carry out common numerical operations on the approximations like multiplication and differentiation:

# Access the underlying Newton interpolating polynomial  
nwt_poly = interpolant.to_newton()  
# Multiply the polynomial -> obtained another polynomial  
prod_poly = nwt_poly * nwt_poly  
# Differentiate the polynomial once -> obtained another polynomial  
diff_poly = nwt_poly.diff(1)  
# Reference function for the (once) differentiated test function
diff_fun = lambda xx: np.sin(10 * xx) + xx * 10 * np.cos(10 * xx)

fig, axs = plt.subplots(1, 2, figsize=(10, 5))  
  
axs[0].plot(xx, prod_poly(xx), label="product polynomial")
axs[0].plot(xx, fun(xx)**2, "k.", label="product test function")
axs[0].legend()
axs[0].set_xlabel("$x$")
axs[0].set_ylabel("$y$")
axs[1].plot(xx, diff_poly(xx), label="differentiated polynomial")
axs[1].plot(xx, diff_fun(xx), "k.", label="differentiated test function")
axs[1].legend()
axs[1].set_xlabel("$x$")
  
plt.show()  

The Getting Started Guides provide more examples on approximating functions and performing operations on interpolating polynomials, including multidimensional cases.

Getting help

For detailed guidance, please refer to the online documentation (stable or latest). It includes detailed installation instructions, usage examples, API references, and contributors guide.

For any other questions related to the package, feel free to post your questions on the GitHub repository Issue page.

Contributing to Minterpy

Contributions to Minterpy are welcome!

We recommend you have a look at the CONTRIBUTING.md first. For a more comprehensive guide visit the Contributors Guide of the documentation.

Citing Minterpy

If you use Minterpy in your research or projects, please consider citing the archived version in RODARE.

The citation for the current public version is:

@software{Minterpy_0_3_0,
  author       = {Hernandez Acosta, Uwe and Thekke Veettil, Sachin Krishnan and Wicaksono, Damar Canggih and Michelfeit, Jannik and Hecht, Michael},
  title        = {{Minterpy} - multivariate polynomial interpolation},
  month        = dec,
  year         = 2024,
  publisher    = {RODARE},
  version      = {v0.3.0},
  doi          = {10.14278/rodare.3354},
  url          = {http://doi.org/10.14278/rodare.3354}
}

Credits and contributors

This work was partly funded by the Center for Advanced Systems Understanding (CASUS), an institute of the Helmholtz-Zentrum Dresden-Rossendorf (HZDR), financed by Germany’s Federal Ministry of Education and Research (BMBF) and by the Saxony Ministry for Science, Culture and Tourism (SMWK) with tax funds on the basis of the budget approved by the Saxony State Parliament.

The Minterpy development team

Minterpy is currently developed and maintained by a small team at the Center for Advanced Systems Understanding (CASUS):

• Damar Wicaksono (HZDR/CASUS)
• Uwe Hernandez Acosta (HZDR/CASUS)
• Janina Schreiber (HZDR/CASUS)

Mathematical foundation

• Michael Hecht (HZDR/CASUS)

Former members and contributors

• Sachin Krishnan Thekke Veettil
• Jannik Kissinger
• Nico Hoffman
• Steve Schmerler (HZDR)
• Vidya Chandrashekar (TU Dresden)

Acknowledgements

• Klaus Steiniger (HZDR/CASUS)
• Patrick Stiller (HZDR)
• Matthias Werner (HZDR)
• Krzysztof Gonciarz (MPI-CBG/CSBD)
• Attila Cangi (HZDR/CASUS)
• Michael Bussmann (HZDR/CASUS)

License

Minterpy is released under the MIT license.