numerical computing

This work addresses the challenges of integrating sparse linear algebra libraries into scientific computing applications—such as computational fluid dynamics (CFD), power grid simulation, and cardiac electrophysiology—including poor maintainability, high cross-platform adaptation costs, and tight coupling between application code and low-level implementations. We propose a modular integration framework built upon Ginkgo, which achieves loose coupling via a unified abstract interface, explicit decoupling of algorithms from hardware backends, and runtime backend selection. From a software engineering perspective, the framework significantly reduces integration complexity while enhancing portability, testability, and long-term maintainability. Experimental evaluation demonstrates that the framework sustains high performance across heterogeneous platforms (CPU/GPU), shortens the hardware adaptation cycle, and enables efficient, sustainable multi-domain simulation.

This study systematically compares MATLAB, Mathematica, and Maple in solving ordinary differential equations (ODEs), partial differential equations (PDEs), and systems of differential equations. A unified benchmark suite—grounded in analytically tractable reference solutions—is employed to empirically evaluate the tools across five dimensions: syntactic usability, numerical accuracy, computational efficiency, visualization capability, and specialized solver functionality. Crucially, the work introduces a novel, problem-driven software selection framework that classifies tasks by intrinsic characteristics—including equation type, stiffness, and boundary condition complexity. Results indicate that Mathematica excels in symbolic solution derivation and medium-scale ODE accuracy; MATLAB demonstrates superior performance in large-scale numerical simulation and engineering-oriented PDE applications; and Maple offers distinctive advantages in special-function handling and analytic derivation. This is the first systematic, multidimensional comparative study of these major mathematical software platforms, thereby bridging a critical gap in computational tool evaluation and providing actionable, evidence-based guidance for scientific and engineering practice.

To address the insufficient time-integration capabilities of the SUNDIALS numerical library in high-performance scientific computing, this project systematically extends its time-stepping solvers. Methodologically, it introduces three novel classes of single-step methods—low-storage Runge–Kutta (LSRK), symplectic structure-preserving block RK, and general-purpose operator-splitting schemes—alongside a new multi-rate adaptive step-size controller and explicit RK-based adjoint sensitivity analysis (filling a longstanding gap). It further enhances nonlinear solvers with Anderson acceleration and improves error handling and logging infrastructure. These contributions significantly improve efficiency, stability, and accuracy for large-scale transient simulations, enabling long-duration, high-fidelity, and multiphysics-coupled modeling. Validation across multiple HPC applications demonstrates speedups of 1.5–3× and markedly improved numerical robustness.

Scientific software deployment faces a productivity–performance gap between high-level prototyping environments (e.g., MATLAB) and production-grade C++ code: scripting languages sacrifice performance, while conventional C++ linear algebra libraries (e.g., BLAS/LAPACK) suffer from verbose interfaces and error-prone manual memory management. This paper introduces a novel C++ linear algebra library built on template metaprogramming and expression templates. It pioneers a compile-time expression optimization framework that enables operator fusion, lazy evaluation, and elimination of temporary objects—delivering MATLAB-like syntactic simplicity without explicit memory management. The design achieves both high code readability and performance competitive with hand-optimized C++. Benchmark results demonstrate speedups of several-fold over conventional C++ implementations. The library has been successfully deployed in production-scale machine learning and signal processing systems.

This work addresses the interoperability challenges arising from inconsistent interfaces among numerical solvers by proposing and implementing MaRDI—a standardized, open interface tailored for nonlinear optimization. Designed with a modular architecture, MaRDI establishes a generic solver adapter layer that enables seamless integration of diverse optimizers and embeds naturally within physics-informed neural network (PINN) training pipelines. Its efficacy is demonstrated through application to the viscous Burgers equation, where it substantially reduces the development overhead and benchmarking costs associated with solver-specific bindings. By abstracting low-level implementation details, MaRDI allows researchers to focus on core algorithmic innovation while significantly enhancing the efficiency and reproducibility of cross-solver experimentation.

This work proposes a unified framework for solving systems of multivariate polynomials and rectangular multiparameter eigenvalue problems, implemented in the open-source MATLAB toolbox MacaulayLab. The approach leverages numerical linear algebra and Macaulay matrix constructions without relying on any specific polynomial basis or monomial ordering. It is the first method capable of efficiently handling both problem classes within a single framework while accurately characterizing positive-dimensional solution components at infinity. Numerical experiments demonstrate that the proposed method matches or surpasses the performance of established software packages such as PHCpack, PNLA, and MultiParEig. To support reproducible research, the authors provide an extensive suite of test cases alongside the toolbox.

This work addresses the high memory and computational complexity typically associated with solving three-dimensional partial differential equations on Cartesian grids. By exploiting tensor-product structure, the proposed method decomposes the 3D operator into one-dimensional banded kernels aligned with coordinate axes, thereby avoiding explicit assembly of the global matrix and enabling a matrix-free solution strategy. Within a unified framework that integrates diverse numerical approaches—including Kronecker product algebra, compact finite differences, isogeometric analysis, and direct diagonalization—the study systematically identifies three key techniques: multi-right-hand-side reshaping, sum factorization, and pencil-style MPI decomposition. These innovations collectively enhance hardware affinity and parallel scalability, reducing algorithmic complexity to O(N) and storage requirements to O(Nₓ + Nᵧ + N_z), thus enabling efficient large-scale 3D PDE simulations.

This work addresses the challenge of selecting the regularization parameter (nugget) in ill-posed linear systems arising in machine learning, where existing adaptive methods lack compatibility with automatic differentiation and suffer from computational inefficiency. To overcome these limitations, we introduce autonugget, a lightweight Python package fully compatible with JAX’s automatic differentiation framework. Our approach uniquely integrates Richardson extrapolation with Tikhonov regularized solutions computed across multiple nugget values, thereby preserving end-to-end differentiability while avoiding the information loss inherent in single-solution strategies. Experimental results demonstrate that autonugget significantly enhances solution accuracy and training stability without compromising rapid prototyping capabilities.

This work addresses a key limitation of conventional LLM-based PDE solvers, which implicitly embed numerical strategies within generated code, making pre-execution validation and post-failure correction challenging. To overcome this, the authors propose AutoPDE, the first framework to explicitly model solution strategies as revisable, decoupled objects separate from implementation code. AutoPDE employs a three-stage pipeline—PDE type identification, numerical method selection, and adaptive parameter tuning—augmented by low-overhead trial solves and a reusable skill library to construct and refine strategies prior to code generation. Evaluated on the PDE Agent Bench, AutoPDE achieves a 54.5% pass rate, outperforming the strongest baseline by 14.2 percentage points, thereby substantially improving both the reliability and interpretability of AI-driven PDE solving.

This work addresses the gap between algorithmic prototypes and efficient implementations in scientific research by proposing a lightweight approach to translate statistical and machine learning algorithms—such as kernel ridge regression and stochastic gradient descent matrix factorization—from mathematical formulations into readable, high-performance C++ code. Leveraging the Eigen template library for core linear algebra operations—including kernel matrix construction, regularized solvers, and vectorized updates—the implementation seamlessly integrates into the Python ecosystem via pybind11, enabling efficient interoperability with NumPy arrays. The project provides concise, reproducible code examples that encapsulate common computational patterns in research, significantly lowering the barrier for researchers to adopt C++ for high-performance development while balancing performance, readability, and usability.