scipy

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.

Scientific software often suffers from poor reproducibility and low sharing rates, primarily because researchers lack formal software engineering training—leading to version chaos, uncontrolled code quality, and cumbersome release processes. To address this, scikit-package introduces a progressive software engineering roadmap tailored for domain scientists. It provides standardized packaging tutorials, automated workflow templates (covering build systems, CI/CD pipelines, documentation generation, and package management), and community-maintained pedagogical resources. Its key innovation lies in adapting professional software engineering practices to the cognitive load of non-specialist programmers, enabling systematic progression from script-based functions to production-ready, open-source package releases. Empirical evaluation demonstrates that scikit-package significantly improves the reproducibility and maintainability of scientific code, enhances community sharing efficiency, and lowers barriers to standardized scientific software publication.

Traditional space-filling experimental designs—e.g., Latin Hypercube Sampling (LHS)—fail for complex simulation models featuring optional and nested hierarchical inputs. To address this, we propose *raxpy*, the first open-source Python toolkit supporting optional and hierarchical inputs. Its core comprises an automatic parsing mechanism leveraging Python type annotations and runtime introspection, tightly integrated with an enhanced hierarchical Latin hypercube sampling algorithm. This enables generation of experimental designs with high input-space coverage and sample uniformity, while natively supporting multiprocessing and distributed execution. Numerical experiments demonstrate that *raxpy* significantly outperforms baseline methods in both coverage and uniformity (p < 0.01). Released under the MIT license, *raxpy* has been successfully integrated into multiple industrial-scale simulation workflows.

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.

The Python ecosystem lacks an efficient, user-friendly, and feature-complete open-source library for molecular fingerprint computation, hindering reproducibility and scalability in cheminformatics tasks such as property prediction and virtual screening. To address this, we introduce FingerPy—the first industrial-grade, open-source molecular fingerprinting library fully compliant with the scikit-learn API and supporting over 30 mainstream fingerprint types. Its core innovations include deep integration of underlying cheminformatics engines (e.g., RDKit), a hybrid multiprocessing/multithreading parallelization strategy, and algorithmic and memory-access optimizations specifically designed for batch fingerprint generation. Experimental evaluation demonstrates that FingerPy achieves state-of-the-art computational performance on widely used fingerprints (e.g., ECFP4, MACCS), outperforming existing open-source tools by 2–5×. Moreover, its native scikit-learn compatibility enables seamless integration into machine learning pipelines, significantly enhancing modeling efficiency and cross-platform reproducibility.

This work addresses the widespread misuse of statistical methods—often stemming from implicit or ambiguous assumptions—which exacerbates the reproducibility crisis in scientific research, particularly in hypothesis testing and meta-analysis where formal verification mechanisms are lacking. To bridge this gap, the authors propose the first formal verification framework tailored for Python-based statistical programs. By developing a Why3-py frontend, they translate dynamically typed, runtime-polymorphic Python code into the WhyML intermediate representation and extend the StatWhy tool to support meta-analysis verification. Integrating program transformation, static analysis, and formal verification techniques, this approach enables, for the first time, automated correctness verification of statistical programs written in Python, effectively uncovering overlooked assumptions and misuses, thereby filling a critical void in the formal verification of statistical software.

This work addresses three core challenges in scientific computing: high-dimensional integration, uncertainty-aware interpolation, and mesh-free PDE modeling. First, we propose a quasi-Monte Carlo (QMC) method leveraging vectorized error estimation and digitally shift-invariant kernels, enabling machine-precision solutions to stochastic PDEs. Second, we introduce a fast multi-task Gaussian process (GP) regression framework that integrates multi-level GPs, randomized low-discrepancy sequences, and Bayesian QMC—achieving scalable high-dimensional interpolation with rigorous uncertainty quantification. Third, we develop a scientific machine learning (sciML) paradigm coupling neural network surrogate models with mesh-free PDE solvers. We release two open-source Python libraries—QMCPy and FastGPs—to support these advances. Extensive validation on benchmark problems—including the Darcy equation, radiative transfer modeling, and failure probability estimation—demonstrates substantial gains in both computational efficiency and numerical accuracy.

This study addresses the challenge of selecting programming languages that balance performance and efficiency for implementing AI algorithms in resource-constrained environments or when standard AI libraries are unavailable. For the first time, five representative AI algorithms—k-means, k-NN, MLP, genetic algorithm, and Mamdani fuzzy inference—are implemented from scratch in Python, C, C++, Rust, Go, and Julia, with strict equivalence in algorithmic logic. Using identical pseudorandom seeds, native language features, and precise timing and memory monitoring, the work conducts a fine-grained, reproducible cross-language evaluation. Results show that C and C++ deliver the best performance, Rust is only 9% slower, while Julia and Go are 3.3× and 5.0× slower, respectively, and Python is up to 315× slower. Memory usage reveals a fixed overhead of 224 MiB for Julia, whereas C, C++, and Rust all remain below 6 MiB; notably, performance rankings vary significantly across algorithm types.

This work addresses the lack of effective support for Kendall’s 3D shape space in existing Python libraries—such as Geomstats—which has hindered the practical application of Riemannian geometry in three-dimensional shape analysis. We present the first systematic implementation of an efficient and user-friendly Python toolkit tailored specifically to Kendall’s 3D shape space, enabling scale-, position-, and orientation-invariant shape modeling and statistical analysis. By providing a ready-to-use, open-source solution for shape statistics on manifolds, this contribution fills a critical software gap in advanced 3D shape analysis, substantially lowering the barrier to entry for researchers, improving computational efficiency, and enhancing the reproducibility of results.

This work proposes GrowLibm, a novel approach for automatically discovering high-value mathematical primitives tailored to floating-point workloads. By repurposing the numerical superoptimizer Herbie as a library learning tool, the method systematically mines, ranks, and deduplicates candidate primitives, leveraging for the first time in adaptive numerical library expansion the search, equivalence reasoning, and cost modeling mechanisms from superoptimization. The approach integrates counterfactual utility evaluation, equivalence generalization, and redundancy pruning, and deploys end-to-end via an LLVM IR matcher. Evaluated on real-world applications including PROJ, CoolProp, and Basilisk, GrowLibm identifies compact, reusable primitives that, when integrated, yield up to 2.2× kernel speedups, improve accuracy from 56.0% to 93.5%, and deliver up to 5% end-to-end performance gains.