Particular is a crate providing a simple way to simulate N-body gravitational interaction of particles in Rust.

The main goal of this crate is to provide users with a simple API to set up N-body gravitational simulations that can easily be integrated into existing game and physics engines. Thus it does not concern itself with numerical integration or other similar tools and instead only focuses on the acceleration calculations.

Multiple algorithms are available to compute the acceleration between particles as ComputeMethods.

Generally speaking, the BruteForce algoritm is more accurate, but slower. The BarnesHut algorithm allows trading accuracy for speed by increasing the theta parameter.
You can read more about their relative performance here.

Particular uses rayon for parallelization. Enable the "parallel" feature to access the available compute methods.

Particular uses wgpu for GPU computation. Enable the "gpu" feature to access the available compute methods.

When possible, it can be useful to implement Particle on a type.

Used when the type has fields named position and mu:

#[derive(Particle)]
struct Body {
    position: Vec3,
    mu: f32,
//  ...
}

Used when the type cannot directly provide a position and a gravitational parameter.

struct Body {
    position: Vec3,
    mass: f32,
//  ...
}

impl Particle for Body {
    type Scalar = f32;

    type Vector = Vec3;
    
    fn position(&self) -> Vec3 {
        self.position
    }
    
    fn mu(&self) -> f32 {
        self.mass * G
    }
}

If you can't implement Particle on a type, you can almost certainly use the fact that it is implemented for tuples of a vector and its scalar type.

let particle = (Vec3::ONE, 5.0);

assert_eq!(particle.position(), Vec3::ONE);
assert_eq!(particle.mu(), 5.0);

In order to get the acceleration of a type, you can use the accelerations or map_accelerations methods on iterators.
These effectively return the original iterator zipped with the acceleration of its items.

As such, you can create an iterator from a collection and get the acceleration using either methods depending on if the items implement Particle.

Pass a mutable reference to a ComputeMethod when calling either method.

// Items are a tuple of a velocity, a position and a mass.
// We map them to a tuple of the position and the mu, since this implements `Particle`.
let accelerations = items
    .iter_mut()
    .map_accelerations(|(_, position, mass)| (*position, *mass * G), &mut cm);

for ((velocity, position, _), acceleration) in accelerations {
    *velocity += acceleration * DT;
    *position += *velocity * DT;
}

for (body, acceleration) in bodies.iter_mut().accelerations(&mut cm) {
    body.velocity += acceleration * DT;
    body.position += body.velocity * DT;
}

Particular is built with performance in mind and uses multiple ways of computing the acceleration between particles in the form of ComputeMethods.

Here is a comparison of the five current available compute methods on an i9 9900KF and an RTX 3080:

Depending on your needs and platform, you may opt for one compute method or another. You can also implement the trait on your own type to combine multiple compute methods and switch between them depending on certain conditions (e.g. the particle count).

PRs are welcome!