Scientific Computing in Rust Monthly #13

Welcome to this month's issue of Scientific Computing in Rust Monthly.

Scientific Computing in Rust Monthly can be viewed online at scientificcomputing.rs/monthly, you can sign up to receive an email copy at mailinglist.scientificcomputing.rs, or you can subscribe using the RSS feed at scientificcomputing.rs/monthly/rss.xml.

Items can be added to the next issue of the newsletter by opening a pull request to the Scientific Computing in Rust Monthly repository on GitHub. You can find more information about adding items here.

Crate of the month: num

crates.io ~ docs.rs ~ source

A crate that includes a collection of types and traits for different number types including big integers, rational numbers and complex numbers, as well as general numeric properties like Integer.

New releases

crate2bib 0.7

Convert a given crate and (optional) version number to a BibLaTeX entry. It scans for existing CITATION.cff files within the repository and also generates entries from the information available at crates.io. The tool can be used as a webapp, python package, command-line utility or Rust crate (see also preprint).

DeepCausality 0.12

DeepCausality started out as a project in advanced computational causality for static and dynamic multimodal causal models, but its most recent release contains a new foundation that comes combined with multiple unified math libraries for:

Geometric Algebra
Differential Topology
Sparse Matrix representation
Tensor Operations including ein_sum

Geometry, topology, sparse matrices, and tensor operations seamlessly compose with each other and thus form the foundation of the new physics crate, a pure Rust implementation of physics formulas across different fields, such as:

Astrophysics: Astrophysics kernels (Schwarzschild radius, orbital velocity, luminosity, Hubble's law, etc.).
Dynamics: Classical mechanics (Kinematics, Newton's laws), state estimation (Kalman filters), and Euler integration.
Electromagnetism: Maxwell's equations, Lorentz force, Poynting vectors, and gauge fields using Geometric Algebra.
Fluids: Fluid dynamics (Bernoulli's principle, Reynolds number, viscosity, pressure).
Materials: Material science properties (Stress, Strain, Hooke's Law, Young's modulus, thermal expansion).
Relativity: Einstein tensors, geodesic deviation, spacetime intervals.
Thermodynamics: Heat diffusion, entropy, partition functions.

The DeepCausality project provides a rich set of code examples for a variety of use cases:

Classical Causal inference, e.g., CATE, DBN, Granger, RCM, SCM
Multi-physics simulations, e.g., Electromagnetism, GRMHD, Particle Physics, etc.
Medicine, e.g., Protein Folding, MRI Tissue Classification, etc.
Material science, e.g., Metamaterials, Topological Insulator, etc.
Avionics: MagNav, Geometric TCAS, etc.

The DeepCausality project invites, physicists engineers, and scientific computing experts from all fields of science and technology to collaborate with us on advancing Rust for scientific computing. The DeepCausality Discord Server is the best place to get started.

ferreus_bbfmm 0.1.0

ferreus_bbfmm is a parallel implementation of the Black Box Fast Multipole Method (BBFMM). BBFMM is a kernel‑independent, hierarchical algorithm for rapidly evaluating all pairwise interactions in a collection of particles.

While originally developed as the fast evaluator for radial basis function (RBF) interpolation, this crate has been generalised to support a broad range of FMM use‑cases where the kernel is smooth (i.e. non‑oscillatory).

Features - 1D (binary tree), 2D (quadtree) and 3D (octree) trees - Optimised low‑rank M2L interactions that leverage symmetries and compression - Adaptive and non‑adaptive tree structures - Support for multiple right‑hand sides - Designed to work with user‑defined kernels via traits - Built on faer for linear algebra, avoiding complex external dependencies - Python bindings and docs available

ferreus_rbf 0.1.0

ferreus_rbf is a fast, memory-efficient, global radial basis function (RBF) interpolation crate written in Rust.

Direct RBF solvers based on dense linear algebra require O(N²) memory and O(N³) work, which quickly becomes impractical beyond tens of thousands of points. ferreus_rbf provides a scalable alternative suitable for millions of points in up to three dimensions.

Features - Supports 1D, 2D and 3D input domains - Scales to datasets with over 1,000,000 source points (subject to hardware) - Optional global trend transforms to capture large‑scale structure in the data - Fast 3D isosurface extraction using a surface‑following, non‑adaptive Surface Nets method - Built on faer for linear algebra, avoiding complex external dependencies - Python bindings and docs available

rsl-interpolation v0.1.16

A re-write of GSL's Interpolation in Rust, a library for interpolating over 1D and 2D arrays, with 1st, 2nd and mixed derivative calculation and 1D numerical integration.

Implemented features:

'Linear', 'Cubic', 'Akima', 'Akima Periodic' and 'Steffen' 1D interpolation types
'Bilinear' and 'Bicubic' 2D interpolation types.
Index look-up Acceleration
Low level interface (interpolation functions)
High level interface (splines)

All of GSL's tests have been transferred, and new ones have been added with values calculated directly from GSL's routines, ensuring that the results are in agreement with GSL to machine precision.

rlst v0.4.0

rlst (Rust Linear Solver Toolbox) 0.4 is the first release of the library that we consider suitable for external users.

It is a feature-rich linear algebra library that includes:

A multi-dimensional array type, allowing for slicing, subviews, axis permutations, and various componentwise operations
Arrays can be allocated on either the stack or the heap. Stack-allocation well suited for small arrays in performance critical loops where heap-based memory allocation should be avoided.
BLAS interface for matrix products, and interface to a number of Lapack operations for dense matrix decompositions, including, LU, QR, SVD, symmetric, and nonsymmetric eigenvalue decompositions
Componentwise operations on array are using a compile-time expression arithmetic that avoids memory allocation of temporaries and efficiently auto-vectorizes complex componentwise operations on arrays.
A sparse matrix module allowing for the creation of CSR matrices on single nodes or via MPI on distributed nodes
Distributed arrays on distributed sparse matrices support a number of componentwise operations
An initial infrastructure for linear algebra on abstract function spaces, including iterative solvers. However, for now only CG is implemented. More is in the work.
Complex-2-Complex FFT via interface to the FFTW library.
A toolbox of distributed communication routines built on top of rsmpi to make MPI computations simpler, including a parallel bucket sort implementation.