chebfun 0.8.0

A Python implementation of Chebfun

ChebPy

A Python implementation of Chebfun

🔬 Numerical computing with Chebyshev series approximations

Symbolic-numeric computation with functions

ChebPy is a Python implementation of Chebfun, bringing the power of Chebyshev polynomial approximations to Python. It allows you to work with functions as first-class objects, performing operations like differentiation, integration, and root-finding with machine precision accuracy.

Table of Contents

• ✨ Features
• 📥 Installation
• 🛠️ Development
• 🚀 Quick Start
• 📖 Documentation
• 📄 License
• 👥 Contributing

---

✨ Features

Work with functions as easily as numbers

• 🔢 Function Approximation: Automatic Chebyshev polynomial approximation of smooth functions
• 📐 Calculus Operations: Differentiation, integration, and root-finding with machine precision
• 📊 Plotting: Beautiful function visualizations with matplotlib integration
• 🧮 Arithmetic: Add, subtract, multiply, and compose functions naturally
• 🎯 Adaptive: Automatically determines optimal polynomial degree for given tolerance
• 🔗 Interoperability: Works seamlessly with NumPy and SciPy ecosystems

---

📥 Installation

Using pip (recommended)

pip install chebpy

From source (development)

git clone https://github.com/chebpy/chebpy.git
cd chebpy
pip install -e .

Note: Use -e flag for editable installation during development

🛠️ Development

For contributors and advanced users

ChebPy uses modern Python development tools for a smooth developer experience:

# 📦 Install development dependencies
make install

# 🧪 Run tests with coverage
make test

# ✨ Format and lint code
make fmt
make lint

# 📓 Start interactive notebooks
make marimo

# 🔍 View test coverage report
make coverage

Development Tools

• Testing: pytest with coverage reporting
• Formatting: ruff for code formatting and linting
• Notebooks: marimo for interactive development
• Task Management: Taskfile for build automation

Quick Start

This figure was generated with the following simple ChebPy code:

import numpy as np
from chebpy import chebfun

# Create functions as chebfuns on interval [0, 10]
f = chebfun(lambda x: np.sin(x**2) + np.sin(x)**2, [0, 10])
g = chebfun(lambda x: np.exp(-(x-5)**2/10), [0, 10])

# Find intersection points
roots = (f - g).roots()

# Plot both functions and mark intersections
ax = f.plot(label='f(x) = sin(x²) + sin²(x)')
g.plot(ax=ax, label='g(x) = exp(-(x-5)²/10)')
ax.plot(roots, f(roots), 'ro', markersize=8, label='Intersections')
ax.legend()
ax.grid(True, alpha=0.3)

More Examples

# Differentiation and integration
f = chebfun(lambda x: np.exp(x) * np.sin(x), [-1, 1])
df_dx = f.diff()          # Derivative
integral = f.sum()        # Definite integral

# Root finding
g = chebfun(lambda x: x**3 - 2*x - 5, [-3, 3])
roots = g.roots()         # All roots in the domain

Convolution

Convolve two functions to produce a new Chebfun on the summed domain:

from chebpy import chebfun
import numpy as np

f = chebfun(lambda x: np.exp(-x**2), [-1, 1])
g = chebfun(lambda x: np.where(np.abs(x) < 0.5, 1.0, 0.0), [-1, 1])

h = f.conv(g)        # h(x) = ∫ f(t) g(x−t) dt, a Chebfun on [−2, 2]
h.plot()

Quasimatrices

Stack functions as columns of an ∞×n matrix and use continuous linear algebra — QR, SVD, least-squares:

from chebpy import Quasimatrix, chebfun

x = chebfun("x")
A = Quasimatrix([1, x, x**2, x**3, x**4, x**5])

Q, R = A.qr()             # QR factorisation → Legendre polynomials
U, S, V = A.svd()         # Singular value decomposition

f = chebfun(lambda t: np.exp(t) * np.sin(6 * t), [-1, 1])
c = A.solve(f)            # Least-squares polynomial fit
f_approx = A @ c          # Reconstruct as a Chebfun

Gaussian Process Regression

Fit a GP to scattered data and get the posterior mean and variance back as Chebfuns — ready for differentiation, integration, and root-finding:

from chebpy import gpr
import numpy as np

rng = np.random.default_rng(1)
x_obs = np.sort(-2 + 4 * rng.random(10))
y_obs = np.sin(np.exp(x_obs))

f_mean, f_var = gpr(x_obs, y_obs, domain=[-2, 2])

f_mean.plot()                     # Posterior mean (a Chebfun)
extrema = f_mean.diff().roots()   # Local extrema via calculus
integral = f_mean.sum()           # Definite integral

---

Documentation

• 🚀 Codespaces: Try ChebPy in your browser
• 📚 Documentation: Full documentation, user guide, and API reference

---

📄 License

ChebPy is licensed under the 3-Clause BSD License.

📜 See the full license in the LICENSE.rst file.

---

👥 Contributing

We welcome contributions! 🎉

Whether you're fixing bugs, adding features, or improving documentation, your help makes ChebPy better for everyone.

Quick Start for Contributors

1. 🍴 Fork the repository
2. 🌿 Create your feature branch

   git checkout -b feature/amazing-feature
   

3. ✨ Make your changes and add tests
4. 🧪 Test your changes

   make test
   

5. 📝 Commit your changes

   git commit -m 'Add amazing feature'
   

6. 🚀 Push to your branch

   git push origin feature/amazing-feature
   

7. 🎯 Open a Pull Request

Resources

• 📋 Contributing Guide
• 🤝 Code of Conduct
• 🐛 Issue Tracker

Acknowledgments 🙏

• Jebel-Quant/rhiza for standardised CI/CD templates and project tooling

---

Made with ❤️ by the ChebPy community

⭐ If you find ChebPy useful, please consider giving it a star! ⭐