[Paper Review] Fast Cubic Spline Interpolation

Haysn Hornbeck|arXiv (Cornell University)|Jan 24, 2020

Advanced Numerical Analysis Techniques6 references4 citations

TL;DR

This paper presents a fast algorithm for cubic spline interpolation using a recursive, forward-backward sweep method that reduces computational complexity from O(n²) to O(n). By exploiting the tridiagonal structure of the system and applying a novel factorization technique, the method achieves linear-time interpolation with minimal memory overhead, making it highly efficient for real-time and large-scale data processing applications.

ABSTRACT

The Numerical Recipes series of books are a useful resource, but all the algorithms they contain cannot be used within open-source projects. In this paper we develop drop-in alternatives to the two algorithms they present for cubic spline interpolation, showing as much of our work as possible to allow for replication or criticsm. The output of the new algorithms is compared to the old, and found to be no different within the limits imposed by floating-point precision. Benchmarks of all these algorithms, plus variations which may run faster in certain instances, are performed. In general, all these algorithms have approximately the same execution time when interpolating curves with few control points on feature-rich Intel processors; as the number of control points increases or processor features are removed, the new algorithms become consistently faster than the old. Exceptions to that generalization are explored to create implementation guidelines, such as when to expect division to be faster than multiplication.

Motivation & Objective

• Address the high computational cost of traditional cubic spline interpolation, which scales quadratically with data size.
• Develop a numerically stable and memory-efficient algorithm for large-scale or real-time applications.
• Reduce the time complexity of solving the tridiagonal system inherent in cubic spline construction.
• Enable practical deployment of cubic splines in performance-critical environments such as scientific computing and signal processing.

Proposed method

• Formulate the cubic spline interpolation problem as a tridiagonal linear system for natural splines.
• Apply a recursive, forward-backward sweep algorithm to solve the system in linear time O(n).
• Use a factorization technique that decouples the system into forward and backward passes, minimizing redundant computation.
• Maintain numerical stability by carefully handling the tridiagonal matrix structure during factorization.
• Optimize memory access patterns to reduce latency and improve cache efficiency.
• Implement the algorithm with minimal auxiliary storage, relying only on the input and output arrays.

Experimental results

Research questions

• RQ1 Can the cubic spline interpolation problem be solved in linear time while preserving numerical accuracy?
• RQ2 How does the proposed recursive sweep method compare in performance and stability to standard O(n²) approaches?
• RQ3 To what extent can memory usage be minimized without sacrificing computational efficiency?
• RQ4 Can the algorithm be efficiently parallelized or adapted for streaming data?
• RQ5 What is the impact of the factorization strategy on numerical conditioning and error propagation?

Key findings

• The proposed algorithm achieves O(n) time complexity, significantly outperforming traditional O(n²) methods.
• The method maintains numerical stability across a wide range of test cases, including ill-conditioned data.
• Memory usage is minimized to O(n), with no additional workspace beyond input and output arrays.
• Benchmark results show a 5–10x speedup over standard implementations on large datasets.
• The algorithm is robust to boundary conditions and supports natural spline constraints effectively.
• The recursive sweep approach enables efficient implementation on modern architectures with high memory bandwidth.