MPCR: Multi-Precision Computations Package in R

In the early days of computing, severe memory constraints made it necessary to use lower floating-point precision. As hardware capabilities have advanced, modern systems, particularly in computational statistics and scientific computing, have widely adopted 64-bit precision to reduce numerical errors and support complex calculations. However, in some applications, double-precision accuracy exceeds practical requirements, prompting interest in lower-precision alternatives that decrease computational complexity while maintaining adequate accuracy. This trend has accelerated with the advent of hardware optimized for low-precision computations, such as leveraging Tensor Cores technology in recent NVIDIA GPUs. Although lower precision can introduce numerical and accuracy challenges, many applications demonstrate robustness under these conditions. Consequently, new multi-precision algorithms have been developed to balance accuracy and computational cost. To facilitate the adoption of these approaches in statistical computing, this article introduces MPCR, a new R package that supports arithmetic operations at 16-, 32-, and 64-bit precision. Written in C++ and integrated with Rcpp, MPCR delivers highly optimized multi-precision computations on both CPU and GPU, enabling seamless low-precision operations. Several examples demonstrate the benefits of MPCR across both performance and accuracy.

💡 Research Summary

The paper introduces MPCR, a new R package that brings multi‑precision arithmetic—supporting 16‑bit half‑precision, 32‑bit single‑precision, and 64‑bit double‑precision—to the R ecosystem. Motivated by the observation that many statistical and scientific applications do not require full double‑precision accuracy, the authors argue that leveraging lower‑precision formats can reduce memory usage and accelerate computation, especially on modern hardware that provides dedicated low‑precision units (e.g., NVIDIA Tensor Cores, Intel DL Boost, ARM NEON/SVE, and emerging AI accelerators).

The authors first review floating‑point standards, describing the bit layout and dynamic range of FP16, FP32, and FP64 as defined by IEEE‑754. They note that while FP16 is widely used for storage, recent GPUs and some CPUs now support native FP16 arithmetic, enabling mixed‑precision strategies where most work is done in low precision and critical steps are refined in higher precision.

MPCR’s architecture is built on C++ with Rcpp as the bridge to R. Core computations are implemented as template functions parameterized by precision, eliminating code duplication. A “precision controller” decides the output precision based on input types and a promotion policy, while a “dispatcher” selects the appropriate template at runtime. This design allows seamless mixing of precisions within a single workflow (e.g., multiplying two single‑precision matrices and storing the result in double‑precision).

Memory allocation is handled per‑object: when a user creates an MPCR vector or matrix, the package allocates a buffer of the requested size and precision on either CPU or GPU. For GPU execution, the package relies on CUDA and cuBLAS, automatically routing FP16 operations to Tensor Cores when available. The R‑side API mirrors familiar base R functions (e.g., chol(), svd(), cbind()) but dispatches to the precision‑aware C++ implementations, requiring minimal code changes for existing R scripts.

Testing is performed with the Catch2 framework, providing extensive unit tests for each linear‑algebra routine across all three precisions. The paper includes a concrete example of testing the singular‑value decomposition, demonstrating how the dispatcher and precision controller cooperate to invoke the correct templated routine.

Performance benchmarks compare MPCR against native R (always double‑precision) on a suite of linear‑algebra kernels. On CPUs, single‑precision kernels achieve roughly a 2× speedup; on GPUs, half‑precision kernels achieve 3‑5× speedups while maintaining error within statistically acceptable bounds. Accuracy experiments show that for many statistical tasks, the numerical differences between FP16/FP32 and FP64 are negligible relative to sampling variability.

Four applied case studies illustrate MPCR in practice: (1) Markov Chain Monte Carlo sampling, where low‑precision likelihood evaluations cut runtime dramatically; (2) spatial statistics models, where covariance matrices stored in half‑precision still yield accurate kriging predictions; (3) principal component analysis, where FP16 SVD provides comparable eigenvectors with far less memory; and (4) Bayesian hierarchical models, where mixed‑precision Gibbs samplers converge as quickly as double‑precision counterparts but run substantially faster. In each case, memory consumption dropped by 40‑70 % and total execution time decreased by 2‑4×.

The authors conclude that MPCR fills a critical gap in the R ecosystem, offering a well‑engineered, high‑performance, and user‑friendly pathway to exploit modern low‑precision hardware. Future work may extend support to 8‑bit floating‑point formats, automatic precision selection heuristics, and broader integration with R’s parallel and distributed computing frameworks. MPCR thus positions R to remain competitive in the era of AI‑driven, precision‑aware scientific computing.