What is Runge's phenomenon and how can I avoid it?

Runge's phenomenon occurs with high-degree polynomials causing large oscillations at boundaries. Avoid it by using piecewise methods like cubic splines or lower-degree polynomials.

How do I choose between cubic splines and polynomial interpolation?

For a few points, polynomial interpolation is feasible. For many points or smooth data, cubic splines provide better stability and continuity. For noisy data, prefer smoothing or least-squares approaches.

How should I validate interpolation results?

Use cross-validation (e.g., leave-one-out error estimation), check boundary behavior for artifacts, and visually inspect the interpolated curve to ensure reasonable accuracy.

interpolation

Scanned

npx machina-cli add skill parcadei/Continuous-Claude-v3/interpolation --openclaw

Files (1)

SKILL.md

4.0 KB

Interpolation

When to Use

Use this skill when working on interpolation problems in numerical methods.

Decision Tree

Assess Data Characteristics
- How many data points? Spacing uniform or non-uniform?
- Is data smooth or noisy?
- Need derivatives at endpoints?
Select Interpolation Method
- Few points (<10): Polynomial (Lagrange, Newton)
- Many points, smooth data: Cubic splines
- Noisy data: Smoothing splines or least squares
- High dimensions: Use simplex-based (n+1 neighbors vs 2^n)
Implement with SciPy
- scipy.interpolate.CubicSpline(x, y) - natural cubic spline
- scipy.interpolate.make_interp_spline(x, y, k=3) - B-spline
- scipy.interpolate.interp1d(x, y, kind='cubic') - 1D interpolation
Validate Results
- Check for Runge's phenomenon at boundaries (high-degree polynomials)
- Cross-validate: leave-one-out error estimation
- Visual inspection of interpolated curve
- sympy_compute.py limit "interp_error" --at boundaries
High-Dimensional Considerations
- Coxeter-Freudenthal-Kuhn triangulation for O(n log n) point location
- Barycentric subdivision for balanced performance

Tool Commands

Scipy_Cubic_Spline

uv run python -c "from scipy.interpolate import CubicSpline; import numpy as np; x = np.array([0,1,2,3]); y = np.array([0,1,4,9]); cs = CubicSpline(x, y); print(cs(1.5))"

Scipy_Bspline

uv run python -c "from scipy.interpolate import make_interp_spline; import numpy as np; x = np.array([0,1,2,3]); y = np.array([0,1,4,9]); bspl = make_interp_spline(x, y, k=3); print(bspl(1.5))"

Sympy_Lagrange

uv run python -m runtime.harness scripts/sympy_compute.py interpolate "[(0,0),(1,1),(2,4)]" --var x

Key Techniques

From indexed textbooks:

[An Introduction to Numerical Analysis... (Z-Library)] DISCUSSION OF THE LITERATURE Discussion of the Literature As noted in the introduction, interpolation theory is a foundation for the development of methods in numerical integration and differentiation, approxima tion theory, and the numerical solution of differential equations. Each of these· topics is developed in the following chapters, and the associated literature is discussed at that point. Additional results on interpolation theory are given in de Boor (1978), Davis (1963), Henrici (1982, chaps.
[Numerical analysis (Burden R.L., Fair... (Z-Library)] The most commonly used form of interpolation is piecewise-polynomial interpolation. If function and derivative values are available, piecewise cubic Hermite interpolation is recommended. This is the preferred method for interpolating values of a function that is the solution to a differential equation.
[Numerical analysis (Burden R.L., Fair... (Z-Library)] Copyright 2010 Cengage Learning. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
[Numerical analysis (Burden R.L., Fair... (Z-Library)] Galerkin and Rayleigh-Ritz methods are both determined by Eq. However, this is not the case for an arbitrary boundary-value problem. A treatment of the similarities and differences in the two methods and a discussion of the wide application of the Galerkin method can be found in [Schul] and in [SF].
[An Introduction to Numerical Analysis... (Z-Library)] Polynomial interpolation theory has a number of important uses. In this text, its primary use is to furnish some mathematical tools that are used in developing methods in the areas of approximation theory, numerical integration, and the numerical solution of differential equations. A second use is in developing means - for working with functions that are stored in tabular form.

Cognitive Tools Reference

See .claude/skills/math-mode/SKILL.md for full tool documentation.

Source

git clone https://github.com/parcadei/Continuous-Claude-v3/blob/main/.claude/skills/math/numerical-methods/interpolation/SKILL.md

View on GitHub

Overview

Interpolation helps estimate values between given data points in numerical methods. This skill guides you through when to apply interpolation, how to select a method based on data characteristics, and how to implement and validate results with SciPy tools. It also covers high-dimensional considerations and common pitfalls like Runge's phenomenon.

How This Skill Works

Technically, interpolation follows a simple workflow: first assess data characteristics (count, spacing, smoothness, endpoint derivatives); then select an appropriate method (polynomial for few points, cubic splines for smooth data, smoothing/least squares for noisy data, or high-dim triangulation). Finally implement with SciPy functions like CubicSpline, make_interp_spline, or interp1d and validate with boundary checks and cross-validation.

When to Use It

Few data points (<10): use polynomial interpolation (Lagrange/Newton).
Many points with smooth data: use cubic splines.
Noisy data: prefer smoothing splines or least-squares interpolation.
High-dimensional data: use simplex-based triangulation for point location.
Need quick validation and error estimation: apply cross-validation and boundary checks.

Quick Start

Step 1: Assess data characteristics (point count, spacing, smoothness, derivatives at endpoints).
Step 2: Select an interpolation method based on data (polynomial for few points; cubic spline for smooth data; smoothing/LS for noisy data; triangulation for high dimensions).
Step 3: Implement with SciPy: e.g., CubicSpline(x, y), make_interp_spline(x, y, k=3), or interp1d(x, y, kind='cubic'); then validate results with boundary checks and cross-validation.

Best Practices

Assess data characteristics: point count, spacing, smoothness, and endpoint derivative requirements.
Choose the method based on data: polynomial for few points; cubic splines for smooth, many-point data; smoothing/LS for noisy data; triangulation for high dimensions.
Avoid high-degree polynomials to minimize Runge's phenomenon; prefer piecewise or spline approaches.
Leverage SciPy tools: CubicSpline, make_interp_spline, and interp1d to implement the chosen method.
Validate results with boundary checks, leave-one-out cross-validation, and visual inspection of the interpolated curve.

Example Use Cases

Polynomial interpolation for a small dataset (<10 points).
CubicSpline interpolation for a smooth, dense dataset.
Smoothing spline to fit noisy sensor measurements.
1D interpolation of temperature over time using interp1d with kind='cubic'.
High-dimensional interpolation using triangulation for a 3D field.

Frequently Asked Questions

Add this skill to your agents