physics_in_parallel 0.1.4

High-performance infrastructure for numerical simulations in physics
Documentation

Physics-in-Parallel

Physics in Parallel is a scientific computing package written in Rust, designed to provide a high-performance, modular, and parallelized infrastructure for computational physics and applied mathematics. The project emphasizes both generality (supporting a wide range of scalar types, tensor structures, and stochastic models) and efficiency (fine-grained memory layouts, data-parallelism, and numerical stability).

Core Goals

  1. Unified Scalar Abstraction

    • A single Scalar trait unifies integers, floating-point numbers, and complex types.
    • Provides a consistent API for fundamental operations (conjugation, norm, square root, finiteness checks) without fragmenting the ecosystem into separate traits.

  2. Tensor Infrastructure

    • Dense tensor structures with flat-memory layouts for cache efficiency.
    • Parallelized elementwise operations (+, -, *, /) using Rayon.
    • Planned support for sparse tensors and symmetry-aware storage (symmetric, antisymmetric, triangular).
    • Serialization and deserialization into human-readable formats (e.g., JSON, string DSL).

  3. Randomized Structures

    • Efficient generators for ensembles of random vectors under different distributions (uniform, Gaussian, etc.).
    • Supports elementwise and vectorwise sampling, crucial for Monte Carlo simulations, stochastic dynamics, and statistical physics models.

  4. Vector Collections (SoA Layout)

    • VectorList<T, D> implements a Structure-of-Arrays (SoA) design: each dimension stored contiguously for SIMD- and cache-friendly operations.
    • Provides raw and high-level accessors, normalization utilities, and batch linear algebra operations.
    • Full set of arithmetic operator overloads with parallel execution.

  5. Parallelism by Default

    • Leverages Rayon to parallelize across vectors, tensor slices, and stochastic sampling automatically.
    • Ensures scaling from laptops to HPC environments with minimal user intervention.

Use Cases

  • Stochastic field dynamics: simulation of Gaussian/random fields, Langevin noise terms, and diffusion processes.
  • Ecological and population dynamics: lattice-based simulations requiring structured random dispersal kernels.
  • General numerical physics: tensor operations, linear algebra utilities, and custom kernels for PDE/ODE solvers.
  • Research reproducibility: portable serialization and string-based tensor construction for tests and validation.

Design Philosophy

  • Minimal but expressive traits: one Scalar trait, extensible tensor backends.
  • Separation of concerns: tensors, random vectors, and physics models live in modular sub-crates.
  • High-performance defaults: SoA layouts, flat indexing, cache-aligned data, and parallelism without explicit boilerplate.
  • Bridging ecosystems: Rust core for speed, JSON/Serde for portability, and Python bindings (planned) for analysis and visualization.

Current Status

The package currently provides:

  • A unified Scalar trait for real and complex numbers.
  • Dense tensor structures with parallelized arithmetic.
  • Random vector generators with uniform/normal sampling.
  • VectorList utilities for parallel linear algebra in SoA format.
  • Serialization and deserialization utilities for testing and interchange.

Planned extensions include:

  • Sparse tensor formats.
  • Advanced symmetry handling in tensors.
  • Physics model modules (diffusion–Langevin systems, lattice ecological dynamics).
  • Python bindings for seamless workflow integration.

Physics in Parallel aims to be a research-grade platform that combines the performance of low-level Rust with the clarity and modularity needed for exploratory and large-scale physics simulations.